@sarj/eslint-plugin 4.2.0 → 5.1.0

package/dist/index.cjs

@@ -35,13 +35,14 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/rules/ban-loose-type-guards-in-tests.ts
+// src/rules/enforce-file-structure.ts
 var import_utils = require("@typescript-eslint/utils");
 
 // src/rules/_paths.ts
 var SCRIPT_FILE_RE = /([\\/]scripts[\\/])|(\.mjs$)/;
 var STORY_FILE_RE = /\.stories\.[cm]?[jt]sx?$/i;
-var GENERATED_FILE_RE = /([\\/](?:generated|openapi-gen|graphql[\\/]types)[\\/])|(\.gen\.[cm]?[jt]sx?$)|(\.generated\.[cm]?[jt]sx?$)|(\.d\.[cm]?ts$)|(\.types\.[cm]?ts$)/;
+var STORY_DIR_RE = /(^|\/)stories(?:[_-][^/]*)?\//i;
+var GENERATED_FILE_RE = /([\\/](?:generated|openapi-gen|graphql[\\/]types|vendor|vendored|external|third[-_]?party)[\\/])|(\.gen\.[cm]?[jt]sx?$)|(\.generated\.[cm]?[jt]sx?$)|(\.d\.[cm]?ts$)|(\.types\.[cm]?ts$)/;
 var GENERATED_MARKER_RE = /(?:@generated\b|generated (?:with|by)|generated (?:graphql )?types|do not edit(?: directly| manually)?)/i;
 function isTestFile(filename) {
   const normalized = filename.replaceAll("\\", "/");
@@ -49,10 +50,13 @@ function isTestFile(filename) {
   if (/[.\-_](test|spec|e2e)\.[cm]?[jt]sx?$/.test(base) || /\.integration\.[cm]?[jt]sx?$/.test(base)) {
     return true;
   }
-  return /(^|\/)(tests?|__tests__|__mocks__|fixtures|e2e|integration)\//.test(normalized);
+  return /(^|\/)(tests?|__tests__|__mocks__|__fixtures__|__testfixtures__|fixtures?|e2e|integration)\//.test(
+    normalized
+  );
 }
 function isStoryFile(filename) {
-  return STORY_FILE_RE.test(filename);
+  const normalized = filename.replaceAll("\\", "/");
+  return STORY_FILE_RE.test(normalized) || STORY_DIR_RE.test(normalized);
 }
 function isGeneratedFile(filename, sourceText = "") {
   return GENERATED_FILE_RE.test(filename.replaceAll("\\", "/")) || GENERATED_MARKER_RE.test(sourceText.slice(0, 2048));
@@ -61,63 +65,27 @@ function isScriptFile(filename) {
   return SCRIPT_FILE_RE.test(filename);
 }
 
-// src/rules/ban-loose-type-guards-in-tests.ts
-var ban_loose_type_guards_in_tests_default = import_utils.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "ban-loose-type-guards-in-tests",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow loose type guards (`typeof` and `in`) in test files. Enforce Zod schemas or strict matchers for type validation."
-    },
-    schema: [],
-    messages: {
-      banLooseTypeGuardsInTests: "Do not use `typeof` or `in` for type validation in tests. Use Zod schemas or strict assertion matchers instead."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (!isTestFile(context.filename)) {
-      return {};
-    }
-    return {
-      UnaryExpression(node) {
-        if (node.operator === "typeof") {
-          context.report({ node, messageId: "banLooseTypeGuardsInTests" });
-        }
-      },
-      BinaryExpression(node) {
-        if (node.operator === "in") {
-          context.report({ node, messageId: "banLooseTypeGuardsInTests" });
-        }
-      }
-    };
-  }
-});
-
 // src/rules/enforce-file-structure.ts
-var import_utils2 = require("@typescript-eslint/utils");
 var classifyStatement = (statement) => {
   switch (statement.type) {
-    case import_utils2.AST_NODE_TYPES.ImportDeclaration:
+    case import_utils.AST_NODE_TYPES.ImportDeclaration:
       return "import";
-    case import_utils2.AST_NODE_TYPES.ExportAllDeclaration:
+    case import_utils.AST_NODE_TYPES.ExportAllDeclaration:
       return "reexport";
-    case import_utils2.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils.AST_NODE_TYPES.ExportNamedDeclaration:
       return statement.declaration === null ? "reexport" : "body";
     default:
       return "body";
   }
 };
-var isStringDirective = (statement) => statement.type === import_utils2.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils2.AST_NODE_TYPES.Literal && typeof statement.expression.value === "string" && statement.expression.value.startsWith("use ");
+var isStringDirective = (statement) => statement.type === import_utils.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils.AST_NODE_TYPES.Literal && typeof statement.expression.value === "string" && statement.expression.value.startsWith("use ");
 var isUseServerDirective = (statement) => {
-  if (statement.type !== import_utils2.AST_NODE_TYPES.ExpressionStatement) return false;
+  if (statement.type !== import_utils.AST_NODE_TYPES.ExpressionStatement) return false;
   const expr = statement.expression;
-  if (expr.type !== import_utils2.AST_NODE_TYPES.Literal) return false;
+  if (expr.type !== import_utils.AST_NODE_TYPES.Literal) return false;
   return expr.value === "use server";
 };
-var enforce_file_structure_default = import_utils2.ESLintUtils.RuleCreator(
+var enforce_file_structure_default = import_utils.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "enforce-file-structure",
@@ -177,7 +145,7 @@ var enforce_file_structure_default = import_utils2.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-client-side-data-fetching.ts
-var import_utils3 = require("@typescript-eslint/utils");
+var import_utils2 = require("@typescript-eslint/utils");
 var FETCH_LIBS = /* @__PURE__ */ new Set(["axios", "ky", "superagent"]);
 var HTTP_METHOD_NAMES = /* @__PURE__ */ new Set([
   "get",
@@ -201,25 +169,25 @@ var ANALYTICS_SEGMENTS = /* @__PURE__ */ new Set([
 ]);
 function isEffectHookCall(node) {
   const callee = node.callee;
-  if (callee.type === import_utils3.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils2.AST_NODE_TYPES.Identifier) {
     return callee.name === "useEffect" || callee.name === "useLayoutEffect";
   }
-  if (callee.type === import_utils3.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils3.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils3.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils2.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils2.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils2.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "useEffect" || callee.property.name === "useLayoutEffect";
   }
   return false;
 }
 function readMethodProperty(optionsArg) {
-  if (!optionsArg || optionsArg.type !== import_utils3.AST_NODE_TYPES.ObjectExpression) {
+  if (!optionsArg || optionsArg.type !== import_utils2.AST_NODE_TYPES.ObjectExpression) {
     return null;
   }
   for (const prop of optionsArg.properties) {
-    if (prop.type !== import_utils3.AST_NODE_TYPES.Property) continue;
+    if (prop.type !== import_utils2.AST_NODE_TYPES.Property) continue;
     if (prop.computed) continue;
     const key = prop.key;
-    const matchesMethodKey = key.type === import_utils3.AST_NODE_TYPES.Identifier && key.name === "method" || key.type === import_utils3.AST_NODE_TYPES.Literal && key.value === "method";
+    const matchesMethodKey = key.type === import_utils2.AST_NODE_TYPES.Identifier && key.name === "method" || key.type === import_utils2.AST_NODE_TYPES.Literal && key.value === "method";
     if (!matchesMethodKey) continue;
-    if (prop.value.type === import_utils3.AST_NODE_TYPES.Literal && typeof prop.value.value === "string") {
+    if (prop.value.type === import_utils2.AST_NODE_TYPES.Literal && typeof prop.value.value === "string") {
       return prop.value.value.toUpperCase();
     }
     return null;
@@ -228,23 +196,23 @@ function readMethodProperty(optionsArg) {
 }
 function isFetchCall(node) {
   const callee = node.callee;
-  if (callee.type === import_utils3.AST_NODE_TYPES.Identifier && callee.name === "fetch") {
+  if (callee.type === import_utils2.AST_NODE_TYPES.Identifier && callee.name === "fetch") {
     const method = readMethodProperty(node.arguments[1]);
     if (method !== null && method !== "GET") {
       return false;
     }
     return true;
   }
-  if (callee.type === import_utils3.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils3.AST_NODE_TYPES.Identifier && FETCH_LIBS.has(callee.object.name) && callee.property.type === import_utils3.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils2.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils2.AST_NODE_TYPES.Identifier && FETCH_LIBS.has(callee.object.name) && callee.property.type === import_utils2.AST_NODE_TYPES.Identifier) {
     return HTTP_METHOD_NAMES.has(callee.property.name);
   }
-  if (callee.type === import_utils3.AST_NODE_TYPES.Identifier && (callee.name === "axios" || callee.name === "ky")) {
+  if (callee.type === import_utils2.AST_NODE_TYPES.Identifier && (callee.name === "axios" || callee.name === "ky")) {
     const firstArg = node.arguments[0];
     const secondArg = node.arguments[1];
     let configArg;
-    if (firstArg?.type === import_utils3.AST_NODE_TYPES.ObjectExpression) {
+    if (firstArg?.type === import_utils2.AST_NODE_TYPES.ObjectExpression) {
       configArg = firstArg;
-    } else if (secondArg?.type === import_utils3.AST_NODE_TYPES.ObjectExpression) {
+    } else if (secondArg?.type === import_utils2.AST_NODE_TYPES.ObjectExpression) {
       configArg = secondArg;
     }
     const method = readMethodProperty(configArg);
@@ -258,13 +226,13 @@ function isFetchCall(node) {
 function extractUrlString(node) {
   const firstArg = node.arguments[0];
   if (!firstArg) return "";
-  if (firstArg.type === import_utils3.AST_NODE_TYPES.Literal && typeof firstArg.value === "string") {
+  if (firstArg.type === import_utils2.AST_NODE_TYPES.Literal && typeof firstArg.value === "string") {
     return firstArg.value;
   }
-  if (firstArg.type === import_utils3.AST_NODE_TYPES.TemplateLiteral) {
+  if (firstArg.type === import_utils2.AST_NODE_TYPES.TemplateLiteral) {
     return firstArg.quasis.map((q) => q.value.cooked).join("");
   }
-  if (firstArg.type === import_utils3.AST_NODE_TYPES.Identifier) {
+  if (firstArg.type === import_utils2.AST_NODE_TYPES.Identifier) {
     return firstArg.name;
   }
   return "";
@@ -274,7 +242,7 @@ function isAnalyticsCall(node) {
   if (url === "") return false;
   return url.split(/[/.]/).some((segment) => ANALYTICS_SEGMENTS.has(segment));
 }
-var no_client_side_data_fetching_default = import_utils3.ESLintUtils.RuleCreator(
+var no_client_side_data_fetching_default = import_utils2.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-client-side-data-fetching",
@@ -312,10 +280,10 @@ var no_client_side_data_fetching_default = import_utils3.ESLintUtils.RuleCreator
 });
 
 // src/rules/no-comment-cruft.ts
-var import_utils5 = require("@typescript-eslint/utils");
+var import_utils4 = require("@typescript-eslint/utils");
 
 // src/rules/_comments.ts
-var import_utils4 = require("@typescript-eslint/utils");
+var import_utils3 = require("@typescript-eslint/utils");
 var REF_RE = /https?:\/\/|\bRFC[- ]?\d+|\bPEP[- ]?\d+|\bCVE-\d{4}|\b(?!UTF-|SHA-|ISO-|AES-|CRC-|MD-|PCM-|EOF-|API-|BASE-)[A-Z][A-Z0-9]{1,9}-\d[A-Z0-9]{0,5}\b|(?<![&\w])#\d{2,6}\b|@[a-z][\w.-]*\.(?:us|com|ai|io|net|org|dev)\b/;
 var VERSION_RE = /(?:>=|<=|==|<|>)\s*v?\d+\.\d+|\bv\d+\.\d+|\b(?:since|until|as of)\s+(?:v?\d+\.\d+|Python\s*\d)/i;
 var UNITS_RE = /[~<>]?\d+(?:\.\d+)?\s?(?:ms|s\b|sec\b|seconds?\b|min\b|minutes?\b|hours?\b|days?\b|KB|MB|MiB|GiB|kHz|Hz|bytes?\b|bit\b|-bit\b|%|px\b|rps\b|qps\b)|\b[1-5]xx\b|\b(?:301|302|304|307|308|400|401|403|404|405|409|410|412|422|425|429|500|501|502|503|504)\b/;
@@ -401,10 +369,10 @@ var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
 var TOKEN_PLURAL_MIN = 4;
 var RESTATABLE_STATEMENTS = /* @__PURE__ */ new Set([
-  import_utils4.AST_NODE_TYPES.ExpressionStatement,
-  import_utils4.AST_NODE_TYPES.ReturnStatement,
-  import_utils4.AST_NODE_TYPES.ThrowStatement,
-  import_utils4.AST_NODE_TYPES.VariableDeclaration
+  import_utils3.AST_NODE_TYPES.ExpressionStatement,
+  import_utils3.AST_NODE_TYPES.ReturnStatement,
+  import_utils3.AST_NODE_TYPES.ThrowStatement,
+  import_utils3.AST_NODE_TYPES.VariableDeclaration
 ]);
 var NARRATION_VERB_RE = /^(?:add|append|assign|build|calculate|call|check|clear|close|compute|convert|copy|count|create|declare|decrement|define|delete|extract|fetch|filter|find|format|generate|get|handle|increment|init|initialise|initialize|insert|iterate|join|load|log|loop|make|map|merge|open|parse|print|process|push|read|remove|render|reset|return|save|send|set|setup|sort|split|start|stop|store|update|validate|wrap|write)(?:s|es|d|ed|ing)?$/i;
 var NARRATION_STOPWORDS = /* @__PURE__ */ new Set([
@@ -469,19 +437,19 @@ function headTokens(source) {
 function isTrivialInitializer(node) {
   return node.declarations.every((declarator) => {
     const init = declarator.init;
-    if (init == null || init.type === import_utils4.AST_NODE_TYPES.Literal) return true;
-    return init.type === import_utils4.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils4.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
+    if (init == null || init.type === import_utils3.AST_NODE_TYPES.Literal) return true;
+    return init.type === import_utils3.AST_NODE_TYPES.ArrayExpression && init.elements.length === 0 || init.type === import_utils3.AST_NODE_TYPES.ObjectExpression && init.properties.length === 0;
   });
 }
 function restatableStatementBelow(comment, sourceCode) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
   if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return null;
-  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils4.AST_NODE_TYPES.Program; node = node.parent) {
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils3.AST_NODE_TYPES.Program; node = node.parent) {
     if (!RESTATABLE_STATEMENTS.has(node.type)) continue;
     if (node.loc.start.line !== token.loc.start.line || node.loc.end.line !== node.loc.start.line) {
       return null;
     }
-    if (node.type === import_utils4.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
+    if (node.type === import_utils3.AST_NODE_TYPES.VariableDeclaration && isTrivialInitializer(node)) {
       return null;
     }
     return sourceCode.getText(node);
@@ -576,7 +544,8 @@ var DUMMY_TRANSLATION_RE = /^(?:increment|return|returns|get|gets|set\b(?! up\b)
 var DIAGRAM_ARROW_RE = /[-=~]{2,}>|<[-=~]{2,}/;
 var CODE_KEYWORD_RE = /^(import |export |const |let |var |function\b|class |interface |type \w|enum |return\b|throw |await |async |if\s*\(|for\s*\(|while\s*\(|switch\s*\(|new |console\.)/;
 var CODE_TAIL_RE = /[;{}()]\s*$|=>\s*$|,\s*$/;
-var CALL_OR_ASSIGN_RE = /^[A-Za-z_$][\w.$[\]]*\s*(?:=(?![=>])|\+=|-=|\*=)\s*\S.*[;)}\]]\s*$|^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
+var ASSIGN_RE = /^[A-Za-z_$][\w.$[\]]*\s*(?:=(?![=>])|\+=|-=|\*=)\s*\S.*[;)}\]]\s*$/;
+var CALL_RE = /^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
 var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
 function stripCommentMarker(line) {
   return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
@@ -590,11 +559,12 @@ function isBanner(text) {
   if (BANNER_FULL_RE.test(t) || isRegionMarker(t)) return true;
   return BANNER_RUN_RE.test(t) && !DIAGRAM_ARROW_RE.test(t);
 }
-function looksLikeCode(text) {
+function looksLikeCode(text, allowCall = true) {
   const t = text.trim();
   if (!t) return false;
   if (CODE_KEYWORD_RE.test(t) && CODE_TAIL_RE.test(t)) return true;
-  return CALL_OR_ASSIGN_RE.test(t);
+  if (ASSIGN_RE.test(t)) return true;
+  return allowCall && CALL_RE.test(t);
 }
 function hasPseudocode(text) {
   return PSEUDOCODE_RE.test(text);
@@ -612,20 +582,24 @@ function isProse(text) {
   }
   return false;
 }
-var JUSTIFICATION_RE = /\b(?:because|since|until|due to|so that|otherwise|which is why|in order to|to avoid|to work around|to prevent)\b/i;
+var JUSTIFICATION_RE = /\b(?:because|since|until|due to|so that|so we|so it|so the|otherwise|which is why|in order to|to avoid|to work around|to prevent|backwards? compat(?:ibility)?|for compatibility)\b/i;
+function restatesWholeStatement(body, statement) {
+  return statement !== null && restatesStatementHead(body, statement.replaceAll("(", " "));
+}
 function isRedundantNarration(body, statementBelow, standalone, isolatedEnumeration, nested) {
   const t = body.trim();
   if (!t || looksLikeCode(t) || hasPseudocode(t)) return false;
   if (standalone) {
-    if (STEP_NARRATION_RE.test(t)) return true;
-    if (META_COMMENTARY_RE.test(t) && !JUSTIFICATION_RE.test(t)) return true;
+    const justified = JUSTIFICATION_RE.test(t);
+    if (STEP_NARRATION_RE.test(t) && !justified) return true;
+    if (META_COMMENTARY_RE.test(t) && !justified) return true;
     if (HELPER_OPENER_RE.test(t) || LETS_RE.test(t)) return true;
     const words = t.split(/\s+/);
-    if (words.length <= 4 && DUMMY_TRANSLATION_RE.test(t) && !/[():=]/.test(t)) {
+    if (words.length > 1 && words.length <= 4 && DUMMY_TRANSLATION_RE.test(t) && !/[():=]/.test(t)) {
       const lowerT = t.toLowerCase();
       const rationaleWords = ["when", "because", "if", "so that", "due to", "for", "instead of", "to prevent", "to avoid", "only"];
-      if (!rationaleWords.some((w) => lowerT.includes(w))) {
-        if (words.length > 1) return true;
+      if (!rationaleWords.some((w) => lowerT.includes(w)) && restatesWholeStatement(t, statementBelow)) {
+        return true;
       }
     }
     if (!nested && isSectionLabel(t)) return true;
@@ -634,13 +608,17 @@ function isRedundantNarration(body, statementBelow, standalone, isolatedEnumerat
   return restatesStatementHead(t, statementBelow);
 }
 var STATEMENT_CONTAINERS = /* @__PURE__ */ new Set([
-  import_utils5.AST_NODE_TYPES.Program,
-  import_utils5.AST_NODE_TYPES.BlockStatement,
-  import_utils5.AST_NODE_TYPES.ClassBody,
-  import_utils5.AST_NODE_TYPES.StaticBlock,
-  import_utils5.AST_NODE_TYPES.SwitchCase,
-  import_utils5.AST_NODE_TYPES.TSModuleBlock,
-  import_utils5.AST_NODE_TYPES.TSInterfaceBody
+  import_utils4.AST_NODE_TYPES.Program,
+  import_utils4.AST_NODE_TYPES.BlockStatement,
+  import_utils4.AST_NODE_TYPES.ClassBody,
+  import_utils4.AST_NODE_TYPES.StaticBlock,
+  import_utils4.AST_NODE_TYPES.SwitchCase,
+  import_utils4.AST_NODE_TYPES.TSModuleBlock,
+  import_utils4.AST_NODE_TYPES.TSInterfaceBody
+]);
+var TYPE_MEMBER_CONTAINERS = /* @__PURE__ */ new Set([
+  import_utils4.AST_NODE_TYPES.TSInterfaceBody,
+  import_utils4.AST_NODE_TYPES.TSTypeLiteral
 ]);
 function runCitesAReference(comments, index) {
   for (let i = index; i >= 0; i--) {
@@ -669,10 +647,10 @@ function hasIllustrationLeadInAbove(comments, index) {
   }
   return false;
 }
-function hasCommentedOutCode(texts, precedingProse) {
+function hasCommentedOutCode(texts, precedingProse, allowCall) {
   for (let i = 0; i < texts.length; i++) {
     const line = texts[i];
-    if (line === void 0 || !looksLikeCode(line) || hasPseudocode(line)) {
+    if (line === void 0 || !looksLikeCode(line, allowCall) || hasPseudocode(line)) {
       continue;
     }
     const prev = i > 0 ? texts[i - 1] : void 0;
@@ -681,7 +659,7 @@ function hasCommentedOutCode(texts, precedingProse) {
   }
   return false;
 }
-var no_comment_cruft_default = import_utils5.ESLintUtils.RuleCreator(
+var no_comment_cruft_default = import_utils4.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-comment-cruft",
@@ -766,7 +744,9 @@ var no_comment_cruft_default = import_utils5.ESLintUtils.RuleCreator(
           }
           const prev = comments[i - 1];
           const precedingProse = prev !== void 0 && prev.type === "Line" && prev.loc.end.line === comment.loc.start.line - 1 && isProse(stripCommentMarker(prev.value));
-          if (hasCommentedOutCode(texts, precedingProse) && !hasIllustrationLeadInAbove(comments, i)) {
+          const container = sourceCode.getNodeByRangeIndex(comment.range[0]);
+          const inTypeMembers = container !== null && TYPE_MEMBER_CONTAINERS.has(container.type);
+          if (hasCommentedOutCode(texts, precedingProse, !inTypeMembers) && !hasIllustrationLeadInAbove(comments, i)) {
             context.report({ node: comment, messageId: "commentedOutCode" });
             continue;
           }
@@ -774,7 +754,6 @@ var no_comment_cruft_default = import_utils5.ESLintUtils.RuleCreator(
             const body = texts[0];
             const statement = restatableStatementBelow(comment, sourceCode);
             const standalone = !isInsideCommentRun(comments, i);
-            const container = sourceCode.getNodeByRangeIndex(comment.range[0]);
             const nested = container !== null && !STATEMENT_CONTAINERS.has(container.type);
             if (body !== void 0 && !runCitesAReference(comments, i) && isRedundantNarration(body, statement, standalone, enumerated.length === 1, nested)) {
               context.report({ node: comment, messageId: "redundantNarration" });
@@ -788,7 +767,7 @@ var no_comment_cruft_default = import_utils5.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-enum.ts
-var import_utils6 = require("@typescript-eslint/utils");
+var import_utils5 = require("@typescript-eslint/utils");
 var DEFAULT_IGNORE_PATTERNS = [
   /[\\/]generated[\\/]/,
   /[\\/]openapi-gen[\\/]/,
@@ -808,7 +787,7 @@ function hasGeneratedMarker(sourceText) {
   const head = sourceText.slice(0, 1024);
   return /@generated\b/.test(head);
 }
-var no_enum_default = import_utils6.ESLintUtils.RuleCreator(
+var no_enum_default = import_utils5.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-enum",
@@ -859,7 +838,7 @@ var no_enum_default = import_utils6.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-insecure-random-id.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils6 = require("@typescript-eslint/utils");
 var STRONG_SECURITY_PATTERN = /token|secret|csrf|password|passwd|apikey|api[-_]?key|nonce|salt|uuid|authid/i;
 var NON_SECURITY_ID_PATTERN = /temp|tmp|cache|correlation|request|req|trace|execution|dev|hmr|mock|test|perf|marker/i;
 var PATH_OR_DOM_MARKER = /[\\/#]|\.[A-Za-z0-9]/;
@@ -1000,7 +979,7 @@ function isConcatenatedIntoPathOrDomId(node) {
   collectStaticStringParts(top, parts);
   return parts.some((part) => PATH_OR_DOM_MARKER.test(part));
 }
-var no_insecure_random_id_default = import_utils7.ESLintUtils.RuleCreator(
+var no_insecure_random_id_default = import_utils6.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-insecure-random-id",
@@ -1044,7 +1023,7 @@ var no_insecure_random_id_default = import_utils7.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-json-stringify-error.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils7 = require("@typescript-eslint/utils");
 var ERROR_NAME_PATTERN = /^(e|err|error|ex|exc)$/i;
 var ERROR_PROP_PATTERN = /^(cause|lastError|error|err|exception|originalError|innerError)$/i;
 var SAFE_STRING_PROPS = /* @__PURE__ */ new Set(["message", "stack", "name"]);
@@ -1178,7 +1157,7 @@ function isGuardedByInstanceofError(node, argExpr, sourceCode) {
 function isJsonStringify(callee) {
   return callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "JSON" && callee.property.type === "Identifier" && callee.property.name === "stringify";
 }
-var no_json_stringify_error_default = import_utils8.ESLintUtils.RuleCreator(
+var no_json_stringify_error_default = import_utils7.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-json-stringify-error",
@@ -1228,10 +1207,10 @@ var no_json_stringify_error_default = import_utils8.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-log-only-catch.ts
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils9 = require("@typescript-eslint/utils");
 
 // src/rules/_logging.ts
-var import_utils9 = require("@typescript-eslint/utils");
+var import_utils8 = require("@typescript-eslint/utils");
 var LOG_METHODS = /* @__PURE__ */ new Set([
   "debug",
   "info",
@@ -1333,12 +1312,92 @@ function createLogMatcher(options = {}) {
 }
 
 // src/rules/no-log-only-catch.ts
-var DEFAULT_IGNORE_PATTERNS2 = [
-  /\.test\./,
-  /\.spec\./,
-  /[\\/]__tests__[\\/]/
-];
-var no_log_only_catch_default = import_utils10.ESLintUtils.RuleCreator(
+var BENCHMARK_DIR_RE = /(?:^|[\\/])benchmarks?[\\/]/;
+var SINGLE_STATEMENT_HOSTS = /* @__PURE__ */ new Set([
+  import_utils9.AST_NODE_TYPES.DoWhileStatement,
+  import_utils9.AST_NODE_TYPES.ForInStatement,
+  import_utils9.AST_NODE_TYPES.ForOfStatement,
+  import_utils9.AST_NODE_TYPES.ForStatement,
+  import_utils9.AST_NODE_TYPES.IfStatement,
+  import_utils9.AST_NODE_TYPES.WhileStatement
+]);
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  import_utils9.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils9.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils9.AST_NODE_TYPES.FunctionExpression
+]);
+function statementSlot(node) {
+  const parent = node.parent;
+  if (parent === void 0) return null;
+  let list;
+  switch (parent.type) {
+    case import_utils9.AST_NODE_TYPES.BlockStatement:
+    case import_utils9.AST_NODE_TYPES.Program:
+    case import_utils9.AST_NODE_TYPES.StaticBlock:
+      list = parent.body;
+      break;
+    case import_utils9.AST_NODE_TYPES.SwitchCase:
+      list = parent.consequent;
+      break;
+    default:
+      return null;
+  }
+  const index = list.indexOf(node);
+  return index === -1 ? null : { list, index };
+}
+function hasFollowingStatement(node) {
+  for (let current = node; current !== void 0 && !FUNCTION_TYPES.has(current.type); current = current.parent) {
+    const slot = statementSlot(current);
+    if (slot !== null && slot.index < slot.list.length - 1) return true;
+  }
+  return false;
+}
+function fallbackFollowsTry(tryStatement) {
+  const body = tryStatement.block.body;
+  const last = body.at(-1);
+  return last?.type === import_utils9.AST_NODE_TYPES.ReturnStatement && hasFollowingStatement(tryStatement);
+}
+function isSeedValue(node) {
+  const inner = node.type === import_utils9.AST_NODE_TYPES.TSAsExpression ? node.expression : node;
+  switch (inner.type) {
+    case import_utils9.AST_NODE_TYPES.Literal:
+      return true;
+    case import_utils9.AST_NODE_TYPES.Identifier:
+      return inner.name === "undefined";
+    case import_utils9.AST_NODE_TYPES.UnaryExpression:
+      return inner.argument.type === import_utils9.AST_NODE_TYPES.Literal;
+    case import_utils9.AST_NODE_TYPES.ArrayExpression:
+      return inner.elements.length === 0;
+    case import_utils9.AST_NODE_TYPES.ObjectExpression:
+      return inner.properties.length === 0;
+    default:
+      return false;
+  }
+}
+function seededFallbackHandled(tryStatement, scope) {
+  const slot = statementSlot(tryStatement);
+  if (slot === null || slot.index === 0) return false;
+  const previous = slot.list[slot.index - 1];
+  if (previous?.type !== import_utils9.AST_NODE_TYPES.VariableDeclaration || previous.kind === "const") {
+    return false;
+  }
+  const declarator = previous.declarations[0];
+  if (previous.declarations.length !== 1 || declarator === void 0) return false;
+  if (declarator.id.type !== import_utils9.AST_NODE_TYPES.Identifier) return false;
+  if (declarator.init == null || !isSeedValue(declarator.init)) return false;
+  const variable = import_utils9.ASTUtils.findVariable(scope, declarator.id.name);
+  if (variable === null) return false;
+  const [tryStart, tryEnd] = tryStatement.block.range;
+  let writtenInTry = false;
+  let readAfter = false;
+  for (const reference of variable.references) {
+    const [start] = reference.identifier.range;
+    if (reference.isWrite() && start >= tryStart && start < tryEnd) writtenInTry = true;
+    if (reference.isRead() && start >= tryStatement.range[1]) readAfter = true;
+  }
+  return writtenInTry && readAfter;
+}
+var no_log_only_catch_default = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-log-only-catch",
@@ -1363,26 +1422,40 @@ var no_log_only_catch_default = import_utils10.ESLintUtils.RuleCreator(
   create(context, [loggingOptions]) {
     const matcher = createLogMatcher(loggingOptions);
     const filename = context.filename;
+    const sourceCode = context.sourceCode;
     function isLoggingCallStatement(statement) {
       if (statement.type !== "ExpressionStatement") {
         return false;
       }
       return matcher.isLoggingCall(statement.expression);
     }
-    const isIgnoredByDefault = DEFAULT_IGNORE_PATTERNS2.some(
-      (re) => re.test(filename)
-    );
-    if (isIgnoredByDefault) {
+    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;
+      const block = tryStatement.parent;
+      if (block?.type !== import_utils9.AST_NODE_TYPES.BlockStatement || block.body.length !== 1 || block.parent === void 0 || !SINGLE_STATEMENT_HOSTS.has(block.parent.type)) {
+        return false;
+      }
+      return hasCommentDirectlyAbove(block.parent);
+    }
+    if (isTestFile(filename) || BENCHMARK_DIR_RE.test(filename.replaceAll("\\", "/"))) {
       return {};
     }
     return {
       CatchClause(node) {
         const statements = node.body.body;
-        const isDocumented = context.sourceCode.getCommentsInside(node.body).length > 0;
+        const isDocumented = sourceCode.getCommentsInside(node.body).length > 0 || hasAdjacentRationale(node);
         if (statements.length === 0) {
           if (isDocumented) {
             return;
           }
+          if (fallbackFollowsTry(node.parent) || seededFallbackHandled(node.parent, sourceCode.getScope(node))) {
+            return;
+          }
           context.report({ node, messageId: "emptyCatch" });
           return;
         }
@@ -1401,11 +1474,12 @@ var no_log_only_catch_default = import_utils10.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-env.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils10 = require("@typescript-eslint/utils");
 var CONFIG_FILE_RE = /(^|[\\/])[\w.-]+\.config\.[cm]?[jt]sx?$/;
 var ENV_BOUNDARY_FILE_RE = /(^|[\\/])(?:env|client-env|server-env|client-settings|server-settings)\.[cm]?[jt]sx?$/;
+var ENV_VALIDATION_MARKER_RE = /\bcreateEnv\s*\(|\bz\.object\s*\(|\.(?:safeParse|parse)\s*\(/;
 function isValidatedEnvBoundary(filename, sourceText) {
-  return ENV_BOUNDARY_FILE_RE.test(filename.replaceAll("\\", "/")) && /\bz\.object\s*\(/.test(sourceText) && /\.parse\s*\(/.test(sourceText);
+  return ENV_BOUNDARY_FILE_RE.test(filename.replaceAll("\\", "/")) && ENV_VALIDATION_MARKER_RE.test(sourceText);
 }
 function isProcessEnv(node) {
   return !node.computed && node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
@@ -1420,9 +1494,15 @@ var BUILD_TIME_CONSTANTS = /* @__PURE__ */ new Set([
   "PROD",
   "SSR"
 ]);
-function isBuildTimeConstantAccess(node) {
+var PLATFORM_MARKERS = /* @__PURE__ */ new Set([
+  "NEXT_RUNTIME",
+  "VERCEL",
+  "VERCEL_ENV",
+  "CI"
+]);
+function isExemptVariableAccess(node) {
   const parent = node.parent;
-  return parent.type === "MemberExpression" && parent.object === node && !parent.computed && parent.property.type === "Identifier" && BUILD_TIME_CONSTANTS.has(parent.property.name);
+  return parent.type === "MemberExpression" && parent.object === node && !parent.computed && parent.property.type === "Identifier" && (BUILD_TIME_CONSTANTS.has(parent.property.name) || PLATFORM_MARKERS.has(parent.property.name));
 }
 function isWriteTarget(node) {
   const access = node.parent.type === "MemberExpression" && node.parent.object === node ? node.parent : node;
@@ -1439,7 +1519,7 @@ function isWholeEnvSpread(node) {
   const parent = node.parent;
   return parent.type === "SpreadElement" && parent.argument === node;
 }
-var no_raw_env_default = import_utils11.ESLintUtils.RuleCreator(
+var no_raw_env_default = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-env",
@@ -1461,7 +1541,7 @@ var no_raw_env_default = import_utils11.ESLintUtils.RuleCreator(
     }
     return {
       MemberExpression(node) {
-        if ((isProcessEnv(node) || isImportMetaEnv(node)) && !isBuildTimeConstantAccess(node) && !isWriteTarget(node) && !isWholeEnvSpread(node)) {
+        if ((isProcessEnv(node) || isImportMetaEnv(node)) && !isExemptVariableAccess(node) && !isWriteTarget(node) && !isWholeEnvSpread(node)) {
           context.report({
             node,
             messageId: "noRawEnv"
@@ -1473,12 +1553,12 @@ var no_raw_env_default = import_utils11.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils11 = require("@typescript-eslint/utils");
 function sentinelKind(arg) {
   if (arg === null) {
     return null;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.Literal) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Literal) {
     if (arg.value === null) {
       return "nullish";
     }
@@ -1490,13 +1570,13 @@ function sentinelKind(arg) {
     }
     return null;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
     return "nullish";
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.ArrayExpression) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
     return "array";
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.ObjectExpression) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ObjectExpression) {
     return "object";
   }
   return null;
@@ -1505,25 +1585,25 @@ function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.Literal && arg.value === null) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Literal && arg.value === null) {
     return true;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.Literal && arg.value === false) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Literal && arg.value === false) {
     return true;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
     return true;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
     return true;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
     return true;
   }
   return false;
 }
 function isFunctionNode(node) {
-  return node.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils12.AST_NODE_TYPES.FunctionExpression || node.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression;
+  return node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils11.AST_NODE_TYPES.FunctionExpression || node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression;
 }
 function isNode(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
@@ -1563,24 +1643,24 @@ function walkWithinScope(node, visit) {
 function containsThrow(node) {
   return walkWithinScope(
     node,
-    (current) => current.type === import_utils12.AST_NODE_TYPES.ThrowStatement
+    (current) => current.type === import_utils11.AST_NODE_TYPES.ThrowStatement
   );
 }
 function bindsName(param, name) {
   switch (param.type) {
-    case import_utils12.AST_NODE_TYPES.Identifier:
+    case import_utils11.AST_NODE_TYPES.Identifier:
       return param.name === name;
-    case import_utils12.AST_NODE_TYPES.AssignmentPattern:
+    case import_utils11.AST_NODE_TYPES.AssignmentPattern:
       return bindsName(param.left, name);
-    case import_utils12.AST_NODE_TYPES.RestElement:
+    case import_utils11.AST_NODE_TYPES.RestElement:
       return bindsName(param.argument, name);
-    case import_utils12.AST_NODE_TYPES.ArrayPattern:
+    case import_utils11.AST_NODE_TYPES.ArrayPattern:
       return param.elements.some(
         (element) => element !== null && bindsName(element, name)
       );
-    case import_utils12.AST_NODE_TYPES.ObjectPattern:
+    case import_utils11.AST_NODE_TYPES.ObjectPattern:
       return param.properties.some(
-        (property) => property.type === import_utils12.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
+        (property) => property.type === import_utils11.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
       );
     default:
       return false;
@@ -1595,7 +1675,7 @@ function subtreeReadsName(node, name) {
     if (found) {
       return;
     }
-    if (current.type === import_utils12.AST_NODE_TYPES.Identifier && current.name === name) {
+    if (current.type === import_utils11.AST_NODE_TYPES.Identifier && current.name === name) {
       found = true;
       return;
     }
@@ -1606,10 +1686,10 @@ function subtreeReadsName(node, name) {
       if (key === "parent") {
         continue;
       }
-      if (key === "key" && current.type === import_utils12.AST_NODE_TYPES.Property && !current.computed) {
+      if (key === "key" && current.type === import_utils11.AST_NODE_TYPES.Property && !current.computed) {
         continue;
       }
-      if (key === "property" && current.type === import_utils12.AST_NODE_TYPES.MemberExpression && !current.computed) {
+      if (key === "property" && current.type === import_utils11.AST_NODE_TYPES.MemberExpression && !current.computed) {
         continue;
       }
       const value = current[key];
@@ -1642,10 +1722,10 @@ var SAFE_PARSE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "URLPattern"
 ]);
 function isParseShapedNode(node) {
-  if (node.type === import_utils12.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils12.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils12.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils11.AST_NODE_TYPES.Identifier) {
     return node.callee.property.name === "parse";
   }
-  if (node.type === import_utils12.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils12.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils11.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils11.AST_NODE_TYPES.Identifier) {
     return SAFE_PARSE_CONSTRUCTORS.has(node.callee.name);
   }
   return false;
@@ -1656,10 +1736,10 @@ var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "arrayBuffer"
 ]);
 function isBodyDecodeNode(node) {
-  return node.type === import_utils12.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils12.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils12.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
+  return node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
 }
 function returnsMatching(stmt, predicate) {
-  return stmt.type === import_utils12.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
+  return stmt.type === import_utils11.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
 }
 function enclosingReturnTypeNode(node) {
   let current = node.parent;
@@ -1677,11 +1757,11 @@ function enclosingFunctionName(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
     if (isFunctionNode(current)) {
-      if ("id" in current && isNode(current.id) && current.id.type === import_utils12.AST_NODE_TYPES.Identifier) {
+      if ("id" in current && isNode(current.id) && current.id.type === import_utils11.AST_NODE_TYPES.Identifier) {
         return current.id.name;
       }
       const parent = current.parent;
-      if (parent?.type === import_utils12.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils12.AST_NODE_TYPES.Identifier) {
+      if (parent?.type === import_utils11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils11.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
       return null;
@@ -1702,10 +1782,10 @@ function isDeclaredBooleanPredicate(catchNode, kind) {
     return false;
   }
   let declared = enclosingReturnTypeNode(catchNode);
-  if (declared?.type === import_utils12.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils12.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
+  if (declared?.type === import_utils11.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils11.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
     declared = declared.typeArguments?.params[0] ?? null;
   }
-  return declared?.type === import_utils12.AST_NODE_TYPES.TSBooleanKeyword;
+  return declared?.type === import_utils11.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function tryReturnsSafeParse(catchNode) {
   const tryBlock = tryBlockOf(catchNode);
@@ -1721,7 +1801,7 @@ function tryReturnsSafeParse(catchNode) {
 function enclosingFunctionBody(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (isFunctionNode(current) && "body" in current && isNode(current.body) && current.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
+    if (isFunctionNode(current) && "body" in current && isNode(current.body) && current.body.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
       return current.body;
     }
     current = current.parent;
@@ -1734,7 +1814,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
     return false;
   }
   return walkWithinScope(functionBody, (current) => {
-    if (current.type !== import_utils12.AST_NODE_TYPES.ReturnStatement) {
+    if (current.type !== import_utils11.AST_NODE_TYPES.ReturnStatement) {
       return false;
     }
     if (isWithin(current, catchNode.body)) {
@@ -1753,13 +1833,13 @@ function returnedSentinelKinds(arg) {
     kinds.add(direct);
     return kinds;
   }
-  if (arg.type === import_utils12.AST_NODE_TYPES.ConditionalExpression) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
     for (const branch of [arg.consequent, arg.alternate]) {
       for (const nested of returnedSentinelKinds(branch)) {
         kinds.add(nested);
       }
     }
-  } else if (arg.type === import_utils12.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
+  } else if (arg.type === import_utils11.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
     for (const nested of returnedSentinelKinds(arg.right)) {
       kinds.add(nested);
     }
@@ -1776,7 +1856,7 @@ function isWithin(node, ancestor) {
   }
   return false;
 }
-var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator(
+var no_sentinel_return_on_catch_default = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sentinel-return-on-catch",
@@ -1804,7 +1884,7 @@ var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator
     const matcher = createLogMatcher(loggingOptions);
     function logsOrReportsError(catchBody, caughtName) {
       return walkWithinScope(catchBody, (current) => {
-        if (current.type !== import_utils12.AST_NODE_TYPES.CallExpression) {
+        if (current.type !== import_utils11.AST_NODE_TYPES.CallExpression) {
           return false;
         }
         if (matcher.isLoggingCall(current)) {
@@ -1821,7 +1901,7 @@ var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator
           return;
         }
         const last = body[body.length - 1];
-        if (last === void 0 || last.type !== import_utils12.AST_NODE_TYPES.ReturnStatement) {
+        if (last === void 0 || last.type !== import_utils11.AST_NODE_TYPES.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -1830,7 +1910,7 @@ var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator
         if (containsThrow(node.body)) {
           return;
         }
-        const caughtName = node.param?.type === import_utils12.AST_NODE_TYPES.Identifier ? node.param.name : null;
+        const caughtName = node.param?.type === import_utils11.AST_NODE_TYPES.Identifier ? node.param.name : null;
         if (logsOrReportsError(node.body, caughtName)) {
           return;
         }
@@ -1857,7 +1937,7 @@ var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator
 });
 
 // src/rules/no-string-concat-in-loop.ts
-var import_utils13 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -1942,7 +2022,7 @@ function enclosingLoop(node) {
   }
   return null;
 }
-var no_string_concat_in_loop_default = import_utils13.ESLintUtils.RuleCreator(
+var no_string_concat_in_loop_default = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-string-concat-in-loop",
@@ -2005,7 +2085,7 @@ var no_string_concat_in_loop_default = import_utils13.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils14 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -2031,13 +2111,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === import_utils14.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils13.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils14.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils13.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils13.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -2052,16 +2132,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils14.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils14.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils13.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils13.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils14.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils13.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils14.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils13.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -2078,7 +2158,7 @@ var isGlobalReference = (node, context) => {
   }
   return true;
 };
-var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
+var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unnecessary-use-client",
@@ -2103,13 +2183,13 @@ var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils14.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils13.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils14.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils13.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -2119,7 +2199,7 @@ var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils14.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils13.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -2132,7 +2212,7 @@ var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils14.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils13.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -2199,8 +2279,8 @@ var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-discriminated-union.ts
+var import_utils14 = require("@typescript-eslint/utils");
 var import_utils15 = require("@typescript-eslint/utils");
-var import_utils16 = require("@typescript-eslint/utils");
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -2210,27 +2290,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils15.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils16.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils15.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils16.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils15.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils16.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils15.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   let optionalPayloadCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils15.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -2246,7 +2326,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   }
   return hasStatusBoolean && optionalCount >= MIN_OPTIONAL_MEMBERS && optionalPayloadCount >= 1;
 }
-var prefer_discriminated_union_default = import_utils15.ESLintUtils.RuleCreator(
+var prefer_discriminated_union_default = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-discriminated-union",
@@ -2274,7 +2354,7 @@ var prefer_discriminated_union_default = import_utils15.ESLintUtils.RuleCreator(
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils16.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils15.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -2287,13 +2367,13 @@ var prefer_discriminated_union_default = import_utils15.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils16 = require("@typescript-eslint/utils");
 var unwrap = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils17.AST_NODE_TYPES.TSAsExpression || current.type === import_utils17.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils17.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils17.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils16.AST_NODE_TYPES.TSAsExpression || current.type === import_utils16.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils16.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils16.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils17.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils16.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -2301,28 +2381,40 @@ var unwrap = (node) => {
   }
   return current ?? null;
 };
+var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
+  "then",
+  "catch",
+  "finally"
+]);
+var isSchemaParseReference = (node) => {
+  const inner = unwrap(node);
+  return inner !== null && inner.type === import_utils16.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils16.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+};
 var isRawPayloadSource = (node) => {
   let current = unwrap(node);
   if (current === null) return false;
-  if (current.type === import_utils17.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils16.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap(current.argument);
   }
-  if (current === null || current.type !== import_utils17.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils16.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap(current.callee);
-  if (callee === null || callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils16.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap(callee.property);
-  if (property === null || property.type !== import_utils17.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils16.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
     return true;
   }
+  if (PROMISE_CHAIN_METHODS.has(property.name)) {
+    return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
+  }
   const object = unwrap(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils17.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
+  return property.name === "parse" && object !== null && object.type === import_utils16.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
   !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
@@ -2330,9 +2422,9 @@ var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils17.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils16.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap(current.callee);
-      const name = callee?.type === import_utils17.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils17.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils17.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      const name = callee?.type === import_utils16.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils16.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils16.AST_NODE_TYPES.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -2354,15 +2446,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils17.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils16.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils17.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils16.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils17.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils16.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils17.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils16.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -2377,23 +2469,43 @@ var findVariable2 = (scope, name) => {
   }
   return null;
 };
-var GUARD_NAME_RE = /^is[A-Z]/;
+var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
+var isValidationRead = (node) => {
+  let current = node;
+  let parent = current.parent;
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils16.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils16.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils16.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils16.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils16.AST_NODE_TYPES.ChainExpression)) {
+    current = parent;
+    parent = parent.parent;
+  }
+  if (parent === null || parent === void 0) return false;
+  if (parent.type === import_utils16.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+    return true;
+  }
+  if (parent.type !== import_utils16.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+    return false;
+  }
+  const callee = parent.callee;
+  if (callee.type === import_utils16.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils16.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils16.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+    return parent.arguments.length === 1;
+  }
+  return callee.type === import_utils16.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+};
 var isGuardTestPosition = (node) => {
   let current = node;
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils17.AST_NODE_TYPES.UnaryExpression:
-      case import_utils17.AST_NODE_TYPES.LogicalExpression:
-      case import_utils17.AST_NODE_TYPES.ChainExpression:
+      case import_utils16.AST_NODE_TYPES.UnaryExpression:
+      case import_utils16.AST_NODE_TYPES.LogicalExpression:
+      case import_utils16.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils17.AST_NODE_TYPES.IfStatement:
-      case import_utils17.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils17.AST_NODE_TYPES.WhileStatement:
-      case import_utils17.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils17.AST_NODE_TYPES.ForStatement:
+      case import_utils16.AST_NODE_TYPES.IfStatement:
+      case import_utils16.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils16.AST_NODE_TYPES.WhileStatement:
+      case import_utils16.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils16.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -2403,13 +2515,13 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
-  if (unwrapped === null || unwrapped.type !== import_utils17.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
   return variable !== null && tracked.has(variable);
 };
-var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreator(
+var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-schema-for-api-payload",
@@ -2429,6 +2541,14 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
       return {};
     }
     const unvalidatedVariables = /* @__PURE__ */ new Set();
+    const isFullyNarrowedPattern = (declarator) => {
+      const declared = context.sourceCode.getDeclaredVariables(declarator);
+      return declared.length > 0 && declared.every(
+        (variable) => variable.references.some(
+          (reference) => isValidationRead(reference.identifier)
+        )
+      );
+    };
     const trackInitializer = (declarator) => {
       if (!isRawPayloadSource(declarator.init)) return;
       const declaredVars = context.sourceCode.getDeclaredVariables(declarator);
@@ -2440,13 +2560,15 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
-            context.report({ node: node.id, messageId: "unparsedJsonAccess" });
+            if (!isFullyNarrowedPattern(node)) {
+              context.report({ node: node.id, messageId: "unparsedJsonAccess" });
+            }
             return;
           }
           if (isUnvalidatedVariableRef(node.init, scope, unvalidatedVariables)) {
@@ -2456,7 +2578,7 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils17.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils16.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -2466,7 +2588,7 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
           }
           return;
         }
-        if (node.left.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -2483,15 +2605,15 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils17.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils16.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils17.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils16.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils17.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -2500,17 +2622,18 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
       },
       MemberExpression(node) {
         if (isInsideAssertion(node)) return;
+        if (isValidationRead(node)) return;
         const scope = context.sourceCode.getScope(node);
         const obj = unwrap(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils17.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils17.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
+          if (parent.type === import_utils16.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils16.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils17.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils16.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -2523,7 +2646,7 @@ var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreat
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -2535,7 +2658,8 @@ var classTokens = (value) => value.split(/\s+/).filter(Boolean);
 var COLOR_PREFIXES = "text|bg|border(?:-[trblxyse])?|ring(?:-offset)?|fill|stroke|from|via|to|divide|decoration|placeholder|accent|caret|shadow|outline";
 var PALETTE = "red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|slate|gray|zinc|neutral|stone";
 var COLOR_FN = "rgba?|hsla?|hwb|oklch|oklab|lab|lch|color";
-var RAW_PALETTE_RE = new RegExp(`^(?:${COLOR_PREFIXES})-(?:${PALETTE})-\\d{2,3}(?:/\\d{1,3})?$`);
+var PALETTE_STEP = "50|[1-9]00|950";
+var RAW_PALETTE_RE = new RegExp(`^(?:${COLOR_PREFIXES})-(?:${PALETTE})-(?:${PALETTE_STEP})(?:/\\d{1,3})?$`);
 var ARBITRARY_COLOR_RE = new RegExp(
   `^(?:${COLOR_PREFIXES})-\\[(?:#[0-9a-fA-F]{3,8}|(?:${COLOR_FN})\\([^\\]]*\\))\\]$`,
   "i"
@@ -2562,6 +2686,7 @@ var STYLE_COLOR_PROPS = /* @__PURE__ */ new Set([
   "lightingColor"
 ]);
 var RAW_COLOR_VALUE_RE = new RegExp(`#[0-9a-fA-F]{3,8}\\b|\\b(?:${COLOR_FN})\\s*\\(`, "i");
+var CSS_VAR_REFERENCE_RE = /var\(\s*--/;
 var STORIES_FILE_RE = /\.stories\.[cm]?[jt]sx?$/i;
 var SEMANTIC_TOKEN_RE = /--(?:background|foreground|primary|secondary|muted|accent|destructive|border|card|popover)\b|(?:bg|text|border)-(?:background|foreground|primary|secondary|muted|accent|destructive|border|card|popover)\b/;
 var DETECTION_FILES = [
@@ -2598,8 +2723,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils18.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils18.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils18.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils17.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils17.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils17.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -2607,10 +2732,25 @@ function jsxElementName(node) {
 function isSvgLikeElementName(name) {
   return name === "svg" || SVG_DEFS_CONTAINERS.has(name) || /svg$/i.test(name);
 }
+var SVG_SHAPE_PRIMITIVES = /* @__PURE__ */ new Set([
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "text",
+  "tspan",
+  "use"
+]);
+var EMAIL_OR_PDF_IMPORT_RE = /@react-(?:email|pdf)\//;
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils18.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils17.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -2621,7 +2761,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils18.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils18.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils18.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils18.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils17.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils17.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils17.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils17.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -2671,11 +2811,11 @@ var hasSemanticTokenSystem = (filename) => {
   return answer;
 };
 var propName = (key) => {
-  if (key.type === import_utils18.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils18.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils17.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils17.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
-var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
+var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-semantic-colors",
@@ -2702,6 +2842,7 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
   defaultOptions: [{}],
   create(context, [options]) {
     if (STORIES_FILE_RE.test(context.filename)) return {};
+    if (EMAIL_OR_PDF_IMPORT_RE.test(context.sourceCode.getText())) return {};
     if (options?.requireSemanticTokens === true && !hasSemanticTokenSystem(context.filename)) {
       return {};
     }
@@ -2710,7 +2851,7 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
         const base = tailwindBase(token);
         if (RAW_PALETTE_RE.test(base)) {
           context.report({ node, messageId: "rawPalette", data: { class: token } });
-        } else if (ARBITRARY_COLOR_RE.test(base)) {
+        } else if (ARBITRARY_COLOR_RE.test(base) && !CSS_VAR_REFERENCE_RE.test(base)) {
           context.report({ node, messageId: "arbitraryColor", data: { class: token } });
         }
       }
@@ -2718,27 +2859,27 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils18.AST_NODE_TYPES.Literal:
+        case import_utils17.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils18.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils17.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils18.AST_NODE_TYPES.ArrayExpression:
+        case import_utils17.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils18.AST_NODE_TYPES.ObjectExpression:
+        case import_utils17.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils18.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils17.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils18.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils17.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils18.AST_NODE_TYPES.LogicalExpression:
+        case import_utils17.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -2746,29 +2887,29 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
+      if (node.type === import_utils17.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         context.report({ node, messageId: "inlineColor", data: { value: node.value } });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils18.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils18.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils18.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils17.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils17.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils17.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -2780,7 +2921,11 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
       // Neutral drawing literals and anything inside an SVG defs container are
       // structural, not UI tokens, so they never fire.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils18.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils17.AST_NODE_TYPES.Literal) return;
+        const owner = node.parent.name;
+        if (owner.type === import_utils17.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+          return;
+        }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
           return;
         }
@@ -2797,7 +2942,7 @@ var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
@@ -2877,7 +3022,7 @@ function getPropertyNode(objNode, propName2) {
   }
   return null;
 }
-var prefer_server_actions_default = import_utils19.ESLintUtils.RuleCreator(
+var prefer_server_actions_default = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-server-actions",
@@ -2952,36 +3097,36 @@ var prefer_server_actions_default = import_utils19.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-assert-never.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils19.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === import_utils20.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils19.AST_NODE_TYPES.Identifier) {
     return callee.name === "assertNever";
   }
-  if (callee.type === import_utils20.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils20.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils19.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils19.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "assertNever";
   }
   return false;
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === import_utils20.AST_NODE_TYPES.ExpressionStatement) {
+  if (statement.type === import_utils19.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils19.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.ReturnStatement) {
+  if (statement.type === import_utils19.AST_NODE_TYPES.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils19.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils20.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils19.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils19.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -2997,12 +3142,12 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils20.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils19.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
 };
-var require_assert_never_default = import_utils20.ESLintUtils.RuleCreator(
+var require_assert_never_default = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-assert-never",
@@ -3040,7 +3185,7 @@ var require_assert_never_default = import_utils20.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -3054,14 +3199,14 @@ function isZodModule(source) {
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils21.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils20.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils21.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils20.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils20.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -3069,25 +3214,25 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
   const method = callee.property.name;
   if (method !== "parse" && method !== "safeParse") return false;
   return looksLikeZodSchema(callee.object);
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils21.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils20.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils21.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils21.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils20.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils20.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
-var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator(
+var require_zod_form_validation_default = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-zod-form-validation",
@@ -3107,14 +3252,14 @@ var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils21.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils20.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -3125,8 +3270,8 @@ var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils20.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -3141,11 +3286,11 @@ var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils21.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
+      return parent !== null && parent !== void 0 && parent.type === import_utils20.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === import_utils21.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils21.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils20.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils20.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -3173,13 +3318,14 @@ var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
   either: { test: ZOD_SCHEMA_NAME_RE, messageId: "zodSchemaName" }
 };
 var CONTAINS_SCHEMA_RE = /schema/i;
+var BENCHMARK_PATH_RE = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
 var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "parse",
   "parseAsync",
@@ -3197,15 +3343,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils22.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils21.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils22.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils22.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils21.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils22.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils21.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -3213,7 +3359,7 @@ var calleeChainStartsWithZ = (node) => {
   }
   return false;
 };
-var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
+var zod_naming_convention_default = import_utils21.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "zod-naming-convention",
@@ -3245,20 +3391,20 @@ var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
     const convention = optionsArg?.convention ?? "either";
     const { test, messageId } = CONVENTIONS[convention];
     const acceptsSchemaWord = convention !== "prefix";
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+    if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     return {
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils22.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils21.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== import_utils22.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils21.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -3271,7 +3417,7 @@ var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-cors-wildcard-with-credentials.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 var ACAO_HEADER = "access-control-allow-origin";
 var ACAC_HEADER = "access-control-allow-credentials";
 var HEADER_SET_METHODS = /* @__PURE__ */ new Set(["setheader", "set", "append"]);
@@ -3413,7 +3559,7 @@ function enclosingScope(node) {
   }
   return void 0;
 }
-var no_cors_wildcard_with_credentials_default = import_utils23.ESLintUtils.RuleCreator(
+var no_cors_wildcard_with_credentials_default = import_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-cors-wildcard-with-credentials",
@@ -3481,9 +3627,9 @@ var no_cors_wildcard_with_credentials_default = import_utils23.ESLintUtils.RuleC
 });
 
 // src/rules/no-silent-promise-catch.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 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");
+  return node.type === import_utils23.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils23.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -3498,21 +3644,21 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
-  return node.type === import_utils24.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils24.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils24.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
+  return node.type === import_utils23.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils23.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
 function isSilentExpression(node) {
   switch (node.type) {
-    case import_utils24.AST_NODE_TYPES.Literal:
+    case import_utils23.AST_NODE_TYPES.Literal:
       return !("regex" in node);
-    case import_utils24.AST_NODE_TYPES.Identifier:
+    case import_utils23.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:
+    case import_utils23.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils23.AST_NODE_TYPES.Literal;
+    case import_utils23.AST_NODE_TYPES.ObjectExpression:
       return node.properties.length === 0;
-    case import_utils24.AST_NODE_TYPES.ArrayExpression:
+    case import_utils23.AST_NODE_TYPES.ArrayExpression:
       return node.elements.length === 0;
-    case import_utils24.AST_NODE_TYPES.TSAsExpression:
+    case import_utils23.AST_NODE_TYPES.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
@@ -3520,7 +3666,7 @@ function isSilentExpression(node) {
 }
 function isSilentHandler(handler) {
   const body = handler.body;
-  if (body.type !== import_utils24.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils23.AST_NODE_TYPES.BlockStatement) {
     return isSilentExpression(body);
   }
   if (body.body.length === 0) {
@@ -3528,13 +3674,13 @@ function isSilentHandler(handler) {
   }
   if (body.body.length === 1) {
     const only = body.body[0];
-    if (only !== void 0 && only.type === import_utils24.AST_NODE_TYPES.ReturnStatement) {
+    if (only !== void 0 && only.type === import_utils23.AST_NODE_TYPES.ReturnStatement) {
       return only.argument === null || isSilentExpression(only.argument);
     }
   }
   return false;
 }
-var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
+var no_silent_promise_catch_default = import_utils23.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-silent-promise-catch",
@@ -3559,7 +3705,7 @@ var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
         return true;
       }
       let statement = call;
-      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils24.AST_NODE_TYPES.VariableDeclaration) {
+      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils23.AST_NODE_TYPES.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -3571,7 +3717,7 @@ var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
     };
     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") {
+        if (node.callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils23.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
           return;
         }
         if (isBodyParseCall(node.callee.object)) {
@@ -3580,14 +3726,14 @@ var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === import_utils24.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
+        if (node.parent.type === import_utils23.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
           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) {
+        if (handler === void 0 || handler.type !== import_utils23.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils23.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -3602,7 +3748,7 @@ var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var CODEMOD_FIXTURE_RE = /[\\/]__testfixtures__[\\/]/;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
   "globalThis",
@@ -3619,14 +3765,14 @@ function matchesAnyPattern2(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils25.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils24.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils25.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils24.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") {
+    if (prop.key.type === import_utils24.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils24.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -3636,9 +3782,9 @@ function initProvablyLacksSignal(init) {
   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;
+  return node.type === import_utils24.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils24.AST_NODE_TYPES.TemplateLiteral;
 }
-var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
+var require_fetch_timeout_default = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-fetch-timeout",
@@ -3675,14 +3821,14 @@ var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils25.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils24.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils25.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils24.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 callee.type === import_utils24.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils24.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils24.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -3702,12 +3848,12 @@ var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-fat-try-blocks.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils26.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils26.AST_NODE_TYPES.FunctionExpression,
-  import_utils26.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils25.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils25.AST_NODE_TYPES.FunctionExpression,
+  import_utils25.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -3805,22 +3951,22 @@ function isNode3(value) {
 }
 function isPureCall(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils26.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type !== import_utils25.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== import_utils26.AST_NODE_TYPES.Identifier) {
+  if (property.type !== import_utils25.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  if (callee.object.type === import_utils26.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === import_utils25.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_utils26.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === import_utils25.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
-function subtreeMatches(stmt, predicate) {
+function subtreeMatches(stmt, predicate, descendIntoFunctions = false) {
   let found = false;
   const visit = (current) => {
     if (found) {
@@ -3834,7 +3980,7 @@ function subtreeMatches(stmt, predicate) {
       if (key === "parent") {
         continue;
       }
-      if (NESTED_FUNCTION_TYPES.has(current.type) && key === "body") {
+      if (!descendIntoFunctions && NESTED_FUNCTION_TYPES.has(current.type) && key === "body") {
         continue;
       }
       const value = current[key];
@@ -3855,20 +4001,20 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils26.AST_NODE_TYPES.AwaitExpression);
+var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils25.AST_NODE_TYPES.AwaitExpression);
 var hasThrowingCallOrNew = (node) => subtreeMatches(
   node,
-  (n) => n.type === import_utils26.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils26.AST_NODE_TYPES.NewExpression && !isPureNew(n)
+  (n) => n.type === import_utils25.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils25.AST_NODE_TYPES.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === import_utils26.AST_NODE_TYPES.ChainExpression || current.type === import_utils26.AST_NODE_TYPES.TSNonNullExpression) {
+  while (current.type === import_utils25.AST_NODE_TYPES.ChainExpression || current.type === import_utils25.AST_NODE_TYPES.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
 }
 function isBareCallStatement(stmt) {
-  return stmt.type === import_utils26.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils26.AST_NODE_TYPES.CallExpression;
+  return stmt.type === import_utils25.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils25.AST_NODE_TYPES.CallExpression;
 }
 function canThrow(stmt) {
   if (hasAwait(stmt)) {
@@ -3877,10 +4023,10 @@ function canThrow(stmt) {
   if (isBareCallStatement(stmt)) {
     return false;
   }
-  if (stmt.type === import_utils26.AST_NODE_TYPES.BlockStatement) {
+  if (stmt.type === import_utils25.AST_NODE_TYPES.BlockStatement) {
     return stmt.body.some(canThrow);
   }
-  if (stmt.type === import_utils26.AST_NODE_TYPES.IfStatement) {
+  if (stmt.type === import_utils25.AST_NODE_TYPES.IfStatement) {
     return hasThrowingCallOrNew(stmt.test) || canThrow(stmt.consequent) || stmt.alternate !== null && canThrow(stmt.alternate);
   }
   return hasThrowingCallOrNew(stmt);
@@ -3891,9 +4037,137 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === import_utils26.AST_NODE_TYPES.ThrowStatement;
+  return last !== void 0 && last.type === import_utils25.AST_NODE_TYPES.ThrowStatement;
+}
+var PASS_THROUGH_PARENTS = /* @__PURE__ */ new Set([
+  import_utils25.AST_NODE_TYPES.IfStatement,
+  import_utils25.AST_NODE_TYPES.TryStatement,
+  import_utils25.AST_NODE_TYPES.CatchClause,
+  import_utils25.AST_NODE_TYPES.LabeledStatement
+]);
+function isTerminalInFunction(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent !== void 0) {
+    if (parent.type === import_utils25.AST_NODE_TYPES.BlockStatement) {
+      if (parent.body[parent.body.length - 1] !== current) {
+        return false;
+      }
+    } else if (parent.type === import_utils25.AST_NODE_TYPES.Program) {
+      return parent.body[parent.body.length - 1] === current;
+    } else if (NESTED_FUNCTION_TYPES.has(parent.type)) {
+      return true;
+    } else if (!PASS_THROUGH_PARENTS.has(parent.type)) {
+      return false;
+    }
+    current = parent;
+    parent = current.parent;
+  }
+  return false;
+}
+function unwrapAwait(expr) {
+  const inner = unwrap2(expr);
+  return inner.type === import_utils25.AST_NODE_TYPES.AwaitExpression ? unwrap2(inner.argument) : inner;
+}
+function handlerEndsByHandingOff(handler) {
+  const body = handler.body.body;
+  const last = body[body.length - 1];
+  if (last === void 0) {
+    return false;
+  }
+  if (last.type === import_utils25.AST_NODE_TYPES.ReturnStatement || last.type === import_utils25.AST_NODE_TYPES.ThrowStatement) {
+    return true;
+  }
+  return last.type === import_utils25.AST_NODE_TYPES.ExpressionStatement && unwrapAwait(last.expression).type === import_utils25.AST_NODE_TYPES.CallExpression;
+}
+function collectBindingNames(pattern, names) {
+  if (pattern.type === import_utils25.AST_NODE_TYPES.Identifier) {
+    names.add(pattern.name);
+    return;
+  }
+  if (pattern.type === import_utils25.AST_NODE_TYPES.ObjectPattern) {
+    for (const property of pattern.properties) {
+      collectBindingNames(
+        property.type === import_utils25.AST_NODE_TYPES.RestElement ? property.argument : property.value,
+        names
+      );
+    }
+    return;
+  }
+  if (pattern.type === import_utils25.AST_NODE_TYPES.ArrayPattern) {
+    for (const element of pattern.elements) {
+      if (element !== null) {
+        collectBindingNames(element, names);
+      }
+    }
+    return;
+  }
+  if (pattern.type === import_utils25.AST_NODE_TYPES.AssignmentPattern || pattern.type === import_utils25.AST_NODE_TYPES.RestElement) {
+    collectBindingNames(
+      pattern.type === import_utils25.AST_NODE_TYPES.AssignmentPattern ? pattern.left : pattern.argument,
+      names
+    );
+  }
+}
+function caughtBindingNames(handler) {
+  const names = /* @__PURE__ */ new Set();
+  if (handler.param !== null) {
+    collectBindingNames(handler.param, names);
+  }
+  return names;
+}
+function isPropertyName(node) {
+  const parent = node.parent;
+  if (parent.type === import_utils25.AST_NODE_TYPES.MemberExpression) {
+    return parent.property === node && !parent.computed;
+  }
+  if (parent.type === import_utils25.AST_NODE_TYPES.Property) {
+    return parent.key === node && !parent.computed;
+  }
+  return false;
+}
+function handlerMentionsCaughtBinding(handler) {
+  const names = caughtBindingNames(handler);
+  if (names.size === 0) {
+    return false;
+  }
+  return subtreeMatches(
+    handler.body,
+    (n) => n.type === import_utils25.AST_NODE_TYPES.Identifier && names.has(n.name) && !isPropertyName(n),
+    true
+  );
+}
+function isSuccessShapedValue(expr) {
+  let current = expr;
+  while (current.type === import_utils25.AST_NODE_TYPES.TSAsExpression || current.type === import_utils25.AST_NODE_TYPES.TSNonNullExpression) {
+    current = current.expression;
+  }
+  if (current.type === import_utils25.AST_NODE_TYPES.Literal) {
+    return current.value === null || current.value === false;
+  }
+  if (current.type === import_utils25.AST_NODE_TYPES.Identifier) {
+    return current.name === "undefined";
+  }
+  if (current.type === import_utils25.AST_NODE_TYPES.UnaryExpression) {
+    return current.operator === "void";
+  }
+  if (current.type === import_utils25.AST_NODE_TYPES.ArrayExpression) {
+    return current.elements.length === 0;
+  }
+  if (current.type === import_utils25.AST_NODE_TYPES.ObjectExpression) {
+    return current.properties.length === 0;
+  }
+  return false;
+}
+var handlerReturnsSuccessShaped = (handler) => subtreeMatches(
+  handler.body,
+  (n) => n.type === import_utils25.AST_NODE_TYPES.ReturnStatement && n.argument !== null && isSuccessShapedValue(n.argument)
+);
+function isTerminalErrorBoundary(node) {
+  const handler = node.handler;
+  return handler !== null && isTerminalInFunction(node) && handlerEndsByHandingOff(handler) && handlerMentionsCaughtBinding(handler) && !handlerReturnsSuccessShaped(handler);
 }
-var no_fat_try_blocks_default = import_utils26.ESLintUtils.RuleCreator(
+var no_fat_try_blocks_default = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-fat-try-blocks",
@@ -3921,6 +4195,9 @@ var no_fat_try_blocks_default = import_utils26.ESLintUtils.RuleCreator(
         if (handlerRethrows(node.handler)) {
           return;
         }
+        if (isTerminalErrorBoundary(node)) {
+          return;
+        }
         const count = node.block.body.filter(canThrow).length;
         if (count <= MAX_TRY_BODY_STATEMENTS) {
           return;
@@ -3937,7 +4214,7 @@ var no_fat_try_blocks_default = import_utils26.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 
 // src/rules/_secret_names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -4199,7 +4476,7 @@ function propertyKeyName2(prop) {
   }
   return null;
 }
-var no_secret_in_log_default = import_utils27.ESLintUtils.RuleCreator(
+var no_secret_in_log_default = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-secret-in-log",
@@ -4276,24 +4553,24 @@ var no_secret_in_log_default = import_utils27.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unsafe-mock-casting.ts
+var import_utils27 = require("@typescript-eslint/utils");
 var import_utils28 = require("@typescript-eslint/utils");
-var import_utils29 = require("@typescript-eslint/utils");
 function isMockTypeReference(node) {
-  if (node.type !== import_utils29.AST_NODE_TYPES.TSTypeReference) {
+  if (node.type !== import_utils28.AST_NODE_TYPES.TSTypeReference) {
     return false;
   }
   const typeName = node.typeName;
-  if (typeName.type === import_utils29.AST_NODE_TYPES.Identifier) {
+  if (typeName.type === import_utils28.AST_NODE_TYPES.Identifier) {
     const name = typeName.name;
     return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
   }
-  if (typeName.type === import_utils29.AST_NODE_TYPES.TSQualifiedName) {
+  if (typeName.type === import_utils28.AST_NODE_TYPES.TSQualifiedName) {
     const rightName = typeName.right.name;
     return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
   }
   return false;
 }
-var no_unsafe_mock_casting_default = import_utils28.ESLintUtils.RuleCreator(
+var no_unsafe_mock_casting_default = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unsafe-mock-casting",
@@ -4325,7 +4602,7 @@ var no_unsafe_mock_casting_default = import_utils28.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -4368,19 +4645,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils30.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils29.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils30.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils29.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils30.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils30.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils29.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils29.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils30.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils29.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -4409,12 +4686,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils29.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils30.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils29.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils30.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils29.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -4422,12 +4699,12 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils30.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils29.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
 }
-var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator(
+var prefer_string_literal_union_default = import_utils29.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-string-literal-union",
@@ -4465,7 +4742,7 @@ var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator
     );
     let services;
     try {
-      services = import_utils30.ESLintUtils.getParserServices(context);
+      services = import_utils29.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -4577,7 +4854,7 @@ var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils30.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils29.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -4665,10 +4942,10 @@ var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils30.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils29.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils30.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils29.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -4677,8 +4954,8 @@ var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator
 });
 
 // src/rules/prefer-zod-enum.ts
-var import_utils31 = require("@typescript-eslint/utils");
-var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
+var import_utils30 = require("@typescript-eslint/utils");
+var prefer_zod_enum_default = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
   name: "prefer-zod-enum",
@@ -4699,20 +4976,20 @@ var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils31.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils30.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
         return null;
       }
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils31.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== import_utils30.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
         return null;
       }
       const values = [];
       for (const element of argument.elements) {
-        if (element === null || element.type !== import_utils31.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils31.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
+        if (element === null || element.type !== import_utils30.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils30.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
           return null;
         }
         const value = element.arguments[0];
-        if (value === void 0 || value.type !== import_utils31.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+        if (value === void 0 || value.type !== import_utils30.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
           return null;
         }
         values.push(value);
@@ -4721,11 +4998,11 @@ var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils31.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== import_utils30.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -4742,7 +5019,7 @@ var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils31.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils31.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils30.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils30.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils30.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils30.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -4764,7 +5041,7 @@ var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -4801,44 +5078,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils32.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils32.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils32.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils32.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils32.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils32.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils32.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils32.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils32.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils32.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils32.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils32.AST_NODE_TYPES.TSArrayType, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils32.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils32.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils32.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils32.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils32.AST_NODE_TYPES.TSIntersectionType, import_utils32.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils31.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils31.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils31.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils31.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils31.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils31.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils31.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils31.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils31.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils31.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils31.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils31.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils31.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils31.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils31.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils31.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils31.AST_NODE_TYPES.TSArrayType, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils31.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils31.AST_NODE_TYPES.TSTypeLiteral, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils31.AST_NODE_TYPES.TSTypeLiteral, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils31.AST_NODE_TYPES.TSTypeLiteral, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils31.AST_NODE_TYPES.TSTypeReference, import_utils31.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils31.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils31.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils31.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils31.AST_NODE_TYPES.TSUnionType, import_utils31.AST_NODE_TYPES.TSTypeReference, import_utils31.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils31.AST_NODE_TYPES.TSUnionType, import_utils31.AST_NODE_TYPES.TSTypeReference, import_utils31.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils31.AST_NODE_TYPES.TSUnionType, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils31.AST_NODE_TYPES.TSUnionType, import_utils31.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils31.AST_NODE_TYPES.TSIntersectionType, import_utils31.AST_NODE_TYPES.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -4847,20 +5124,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils32.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils31.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils32.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils31.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils32.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils31.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils32.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils31.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -4884,7 +5161,7 @@ function leafAgrees(leaf, annotation) {
   }
   return expected.includes(core.type);
 }
-var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
+var prefer_zod_infer_default = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
   name: "prefer-zod-infer",
@@ -4927,14 +5204,14 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils32.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils31.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils32.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils31.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -4943,19 +5220,19 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
     }
     function methodName(call) {
       const callee = call.callee;
-      return callee.type === import_utils32.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils32.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils31.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils31.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === import_utils32.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils31.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils32.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils31.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -4986,16 +5263,16 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils32.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils31.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils32.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils31.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils32.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils32.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils31.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils31.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -5006,11 +5283,11 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils32.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils31.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils32.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils32.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils31.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils31.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -5024,8 +5301,8 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils32.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils32.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils31.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils31.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -5033,11 +5310,11 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
         }
         return;
       }
-      if (node.type === import_utils32.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils31.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils32.AST_NODE_TYPES.TSUnionType || node.type === import_utils32.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils31.AST_NODE_TYPES.TSUnionType || node.type === import_utils31.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -5081,13 +5358,13 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils32.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils32.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils32.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils32.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils31.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils31.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils32.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils31.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -5097,14 +5374,14 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
       },
       /** Guard (f): `XSchema.transform(...)` anywhere in the module. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils32.AST_NODE_TYPES.Identifier && node.property.type === import_utils32.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils31.AST_NODE_TYPES.Identifier && node.property.type === import_utils31.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Guard (c): `z.ZodType<T>` and every other type argument it carries. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils32.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils32.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils32.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils31.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils31.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils31.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -5122,7 +5399,7 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils32.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils31.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -5167,10 +5444,10 @@ var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-offset-pagination.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 
 // src/rules/_sql.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 function stripSqlNoise(text) {
   const out = [...text];
   const n = text.length;
@@ -5231,13 +5508,13 @@ function stripSqlNoise(text) {
 var SUBSTITUTION_MARKER = "?";
 function sqlTextOf(node) {
   switch (node.type) {
-    case import_utils33.AST_NODE_TYPES.Literal:
+    case import_utils32.AST_NODE_TYPES.Literal:
       return typeof node.value === "string" ? node.value : null;
-    case import_utils33.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils32.AST_NODE_TYPES.TemplateLiteral:
       return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join(SUBSTITUTION_MARKER);
-    case import_utils33.AST_NODE_TYPES.TaggedTemplateExpression:
+    case import_utils32.AST_NODE_TYPES.TaggedTemplateExpression:
       return sqlTextOf(node.quasi);
-    case import_utils33.AST_NODE_TYPES.BinaryExpression: {
+    case import_utils32.AST_NODE_TYPES.BinaryExpression: {
       if (node.operator !== "+") {
         return null;
       }
@@ -5245,7 +5522,7 @@ function sqlTextOf(node) {
       const right = sqlTextOf(node.right);
       return left !== null && right !== null ? left + right : null;
     }
-    case import_utils33.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils32.AST_NODE_TYPES.ArrayExpression: {
       const parts = [];
       for (const element of node.elements) {
         if (element === null) {
@@ -5265,7 +5542,7 @@ function sqlTextOf(node) {
 }
 function isJoinedFragmentArray(node) {
   const parent = node.parent;
-  return parent?.type === import_utils33.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils33.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils33.AST_NODE_TYPES.CallExpression;
+  return parent?.type === import_utils32.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils32.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils32.AST_NODE_TYPES.CallExpression;
 }
 function markConsumed(node, consumed) {
   consumed.add(node);
@@ -5315,7 +5592,7 @@ function createSqlListener(handler) {
 // src/rules/no-offset-pagination.ts
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
 var OFFSET_GATE = /offset/i;
-var no_offset_pagination_default = import_utils34.ESLintUtils.RuleCreator(
+var no_offset_pagination_default = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-offset-pagination",
@@ -5344,15 +5621,15 @@ var no_offset_pagination_default = import_utils34.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-positional-tuple-return.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 var MIN_ELEMENTS = 2;
 var ACCESSOR_PAIR_LENGTH = 2;
 var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited"]);
 function tupleReturnType(node) {
-  if (node.type === import_utils35.AST_NODE_TYPES.TSTupleType) {
+  if (node.type === import_utils34.AST_NODE_TYPES.TSTupleType) {
     return node;
   }
-  if (node.type === import_utils35.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+  if (node.type === import_utils34.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params[0];
     return argument === void 0 ? null : tupleReturnType(argument);
   }
@@ -5366,30 +5643,30 @@ function isPermittedTuple(tuple, sourceCode) {
   if (elements.length < MIN_ELEMENTS) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSRestType)) {
+  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSRestType)) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSNamedTupleMember)) {
+  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSNamedTupleMember)) {
     return true;
   }
-  if (elements[0]?.type === import_utils35.AST_NODE_TYPES.TSLiteralType) {
+  if (elements[0]?.type === import_utils34.AST_NODE_TYPES.TSLiteralType) {
     return true;
   }
-  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSFunctionType)) {
+  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSFunctionType)) {
     return true;
   }
   const texts = new Set(elements.map((element) => normalizedText(sourceCode, element)));
   return texts.size === 1;
 }
 function functionName(node) {
-  if (node.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration) {
     return node.id?.name ?? null;
   }
   const parent = node.parent;
-  if (parent?.type === import_utils35.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if (parent?.type === import_utils34.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils34.AST_NODE_TYPES.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === import_utils35.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils35.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils35.AST_NODE_TYPES.Property) && parent.key.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if ((parent?.type === import_utils34.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils34.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils34.AST_NODE_TYPES.Property) && parent.key.type === import_utils34.AST_NODE_TYPES.Identifier) {
     return parent.key.name;
   }
   return null;
@@ -5397,7 +5674,7 @@ function functionName(node) {
 function isInlineExported(node) {
   for (let current = node; current != null; current = current.parent) {
     const parent = current.parent;
-    if (parent?.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (parent?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -5406,18 +5683,18 @@ function isInlineExported(node) {
 function moduleScopeBindingName(node) {
   let current = node;
   let child = node;
-  while (current.parent != null && current.parent.type !== import_utils35.AST_NODE_TYPES.Program) {
+  while (current.parent != null && current.parent.type !== import_utils34.AST_NODE_TYPES.Program) {
     child = current;
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils35.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils34.AST_NODE_TYPES.Program) {
     return null;
   }
-  if (current.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils35.AST_NODE_TYPES.ClassDeclaration) {
+  if (current.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils34.AST_NODE_TYPES.ClassDeclaration) {
     return current.id?.name ?? null;
   }
-  if (current.type === import_utils35.AST_NODE_TYPES.VariableDeclaration) {
-    if (child.type !== import_utils35.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils35.AST_NODE_TYPES.Identifier) {
+  if (current.type === import_utils34.AST_NODE_TYPES.VariableDeclaration) {
+    if (child.type !== import_utils34.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils34.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return child.id.name;
@@ -5427,19 +5704,19 @@ function moduleScopeBindingName(node) {
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
-        if (specifier.exportKind !== "type" && specifier.local.type === import_utils35.AST_NODE_TYPES.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === import_utils34.AST_NODE_TYPES.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils35.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils34.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === import_utils35.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils35.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils34.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils34.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -5455,7 +5732,7 @@ function isExported(node, specifierExports) {
   const binding = moduleScopeBindingName(node);
   return binding !== null && specifierExports.has(binding);
 }
-var no_positional_tuple_return_default = import_utils35.ESLintUtils.RuleCreator(
+var no_positional_tuple_return_default = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-positional-tuple-return",
@@ -5503,16 +5780,16 @@ var no_positional_tuple_return_default = import_utils35.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-repeated-string-literal.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 var MIN_LENGTH = 40;
 var MIN_DISTINCT_SCOPES = 2;
 var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
-var FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils36.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils36.AST_NODE_TYPES.FunctionExpression,
-  import_utils36.AST_NODE_TYPES.ArrowFunctionExpression
+var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
+  import_utils35.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils35.AST_NODE_TYPES.FunctionExpression,
+  import_utils35.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -5523,7 +5800,7 @@ function preview(value) {
 }
 function enclosingFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (FUNCTION_TYPES.has(current.type)) {
+    if (FUNCTION_TYPES2.has(current.type)) {
       return current;
     }
   }
@@ -5534,9 +5811,9 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  return parent.type === import_utils36.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils36.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils36.AST_NODE_TYPES.TSImportType || parent.type === import_utils36.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils36.AST_NODE_TYPES.TSLiteralType;
+  return parent.type === import_utils35.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils35.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils35.AST_NODE_TYPES.TSImportType || parent.type === import_utils35.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils35.AST_NODE_TYPES.TSLiteralType;
 }
-var no_repeated_string_literal_default = import_utils36.ESLintUtils.RuleCreator(
+var no_repeated_string_literal_default = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-repeated-string-literal",
@@ -5576,7 +5853,7 @@ var no_repeated_string_literal_default = import_utils36.ESLintUtils.RuleCreator(
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === import_utils36.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.parent.type === import_utils35.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -5610,7 +5887,7 @@ var no_repeated_string_literal_default = import_utils36.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-select-star.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils36 = require("@typescript-eslint/utils");
 var QUERY_SHAPE = /\bSELECT\b[\s\S]*?\bFROM\b/i;
 var SELECT_KEYWORD = /\bSELECT\b/gi;
 var FROM_KEYWORD = /^FROM\b/i;
@@ -5650,7 +5927,7 @@ function hasRealSelectStar(sql) {
   }
   return false;
 }
-var no_select_star_default = import_utils37.ESLintUtils.RuleCreator(
+var no_select_star_default = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-select-star",
@@ -5679,7 +5956,7 @@ var no_select_star_default = import_utils37.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sleep-in-test-body.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS = /* @__PURE__ */ new Set([
   "it",
@@ -5687,43 +5964,43 @@ var TEST_CALLERS = /* @__PURE__ */ new Set([
   "beforeEach",
   "afterEach"
 ]);
-var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
-  import_utils38.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils38.AST_NODE_TYPES.FunctionExpression,
-  import_utils38.AST_NODE_TYPES.ArrowFunctionExpression
+var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
+  import_utils37.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils37.AST_NODE_TYPES.FunctionExpression,
+  import_utils37.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === import_utils38.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === import_utils37.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === import_utils38.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils38.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  return node.type === import_utils37.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== import_utils38.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== import_utils37.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== import_utils38.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils38.AST_NODE_TYPES.FunctionExpression) {
+  if (executor?.type !== import_utils37.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils37.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const body = executor.body;
-  if (body.type !== import_utils38.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils37.AST_NODE_TYPES.BlockStatement) {
     return isTimedSetTimeout(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === import_utils38.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+    (stmt) => stmt.type === import_utils37.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === import_utils38.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === import_utils37.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
 }
 function nearestEnclosingFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (!FUNCTION_TYPES2.has(current.type)) {
+    if (!FUNCTION_TYPES3.has(current.type)) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils38.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils37.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -5731,29 +6008,29 @@ function nearestEnclosingFunction(node) {
   return null;
 }
 function testCallerName(callee) {
-  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.MemberExpression) {
     return testCallerName(callee.object);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.CallExpression) {
     return testCallerName(callee.callee);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName(callee.tag);
   }
   return null;
 }
 function isTestBody(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils38.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils37.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName(call.callee);
   return name !== null && TEST_CALLERS.has(name);
 }
-var no_sleep_in_test_body_default = import_utils38.ESLintUtils.RuleCreator(
+var no_sleep_in_test_body_default = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sleep-in-test-body",
@@ -5795,52 +6072,222 @@ var no_sleep_in_test_body_default = import_utils38.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-conditional-in-test.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 var TEST_CALLERS2 = /* @__PURE__ */ new Set(["it", "test"]);
-var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils39.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils39.AST_NODE_TYPES.FunctionExpression,
-  import_utils39.AST_NODE_TYPES.ArrowFunctionExpression
+var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
+  import_utils38.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils38.AST_NODE_TYPES.FunctionExpression,
+  import_utils38.AST_NODE_TYPES.ArrowFunctionExpression
+]);
+var ASSERTION_ROOTS = /* @__PURE__ */ new Set([
+  "expect",
+  "expectTypeOf",
+  "assert",
+  "assertType"
+]);
+var TYPE_ASSERTION_ROOTS = /* @__PURE__ */ new Set([
+  "expectTypeOf",
+  "assertType"
 ]);
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
-    if (FUNCTION_TYPES3.has(current.type)) {
+    if (FUNCTION_TYPES4.has(current.type)) {
       return current;
     }
   }
   return null;
 }
 function testCallerName2(callee) {
-  if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils39.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === import_utils39.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === import_utils39.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils39.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils38.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName2(call.callee);
   return name !== null && TEST_CALLERS2.has(name);
 }
-var no_conditional_in_test_default = import_utils39.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "no-conditional-in-test",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow conditional logic (if, switch, ternary) in test bodies, which can hide missing assertions or test multiple code paths."
+function subtreeMatches2(node, predicate, descendIntoFunctions = true) {
+  let found = false;
+  const visit = (current) => {
+    if (found) {
+      return;
+    }
+    if (predicate(current)) {
+      found = true;
+      return;
+    }
+    for (const key of Object.keys(current)) {
+      if (key === "parent") {
+        continue;
+      }
+      if (!descendIntoFunctions && FUNCTION_TYPES4.has(current.type) && key === "body") {
+        continue;
+      }
+      const value = current[key];
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (typeof child === "object" && child !== null && typeof child.type === "string") {
+            visit(child);
+          }
+        }
+      } else if (typeof value === "object" && value !== null && typeof value.type === "string") {
+        visit(value);
+      }
+      if (found) {
+        return;
+      }
+    }
+  };
+  visit(node);
+  return found;
+}
+function rootIdentifier(node) {
+  switch (node.type) {
+    case import_utils38.AST_NODE_TYPES.Identifier:
+      return node.name;
+    case import_utils38.AST_NODE_TYPES.MemberExpression:
+      return rootIdentifier(node.object);
+    case import_utils38.AST_NODE_TYPES.UnaryExpression:
+      return rootIdentifier(node.argument);
+    case import_utils38.AST_NODE_TYPES.AwaitExpression:
+      return rootIdentifier(node.argument);
+    case import_utils38.AST_NODE_TYPES.ChainExpression:
+    case import_utils38.AST_NODE_TYPES.TSNonNullExpression:
+    case import_utils38.AST_NODE_TYPES.TSAsExpression:
+      return rootIdentifier(node.expression);
+    case import_utils38.AST_NODE_TYPES.BinaryExpression:
+    case import_utils38.AST_NODE_TYPES.LogicalExpression:
+      return rootIdentifier(node.left);
+    case import_utils38.AST_NODE_TYPES.CallExpression:
+      return rootIdentifier(node.callee);
+    default:
+      return null;
+  }
+}
+function calleeRootName(call) {
+  let current = call.callee;
+  for (; ; ) {
+    if (current.type === import_utils38.AST_NODE_TYPES.Identifier) {
+      return current.name;
+    }
+    if (current.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+      continue;
+    }
+    if (current.type === import_utils38.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+      continue;
+    }
+    if (current.type === import_utils38.AST_NODE_TYPES.ChainExpression || current.type === import_utils38.AST_NODE_TYPES.TSNonNullExpression) {
+      current = current.expression;
+      continue;
+    }
+    return null;
+  }
+}
+var isAssertionCall = (node) => node.type === import_utils38.AST_NODE_TYPES.CallExpression && ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
+var isTypeAssertionCall = (node) => node.type === import_utils38.AST_NODE_TYPES.CallExpression && TYPE_ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
+var containsAssertion = (node) => subtreeMatches2(node, isAssertionCall);
+var containsSkipCall = (node) => subtreeMatches2(
+  node,
+  (current) => current.type === import_utils38.AST_NODE_TYPES.CallExpression && current.callee.type === import_utils38.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils38.AST_NODE_TYPES.Identifier && current.callee.property.name === "skip"
+);
+var containsEscape = (node) => subtreeMatches2(
+  node,
+  (current) => current.type === import_utils38.AST_NODE_TYPES.ReturnStatement || current.type === import_utils38.AST_NODE_TYPES.ContinueStatement || current.type === import_utils38.AST_NODE_TYPES.BreakStatement,
+  false
+);
+function branchStatements(branch) {
+  return branch.type === import_utils38.AST_NODE_TYPES.BlockStatement ? branch.body : [branch];
+}
+function previousSibling(node) {
+  const parent = node.parent;
+  let siblings = null;
+  if (parent.type === import_utils38.AST_NODE_TYPES.BlockStatement || parent.type === import_utils38.AST_NODE_TYPES.Program || parent.type === import_utils38.AST_NODE_TYPES.StaticBlock) {
+    siblings = parent.body;
+  } else if (parent.type === import_utils38.AST_NODE_TYPES.SwitchCase) {
+    siblings = parent.consequent;
+  }
+  if (siblings === null) {
+    return null;
+  }
+  const index = siblings.indexOf(node);
+  return index > 0 ? siblings[index - 1] ?? null : null;
+}
+function isPinnedNarrowingGuard(node) {
+  const testRoot = rootIdentifier(node.test);
+  if (testRoot === null) {
+    return false;
+  }
+  const previous = previousSibling(node);
+  if (previous === null || previous.type !== import_utils38.AST_NODE_TYPES.ExpressionStatement) {
+    return false;
+  }
+  let matched = false;
+  subtreeMatches2(previous, (current) => {
+    if (current.type !== import_utils38.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils38.AST_NODE_TYPES.Identifier || current.callee.name !== "expect") {
+      return false;
+    }
+    const subject = current.arguments[0];
+    if (subject === void 0) {
+      return false;
+    }
+    if (rootIdentifier(subject) === testRoot) {
+      matched = true;
+      return true;
+    }
+    return false;
+  });
+  return matched;
+}
+function isThrowingGuard(node) {
+  if (node.alternate !== null) {
+    return false;
+  }
+  const statements = branchStatements(node.consequent);
+  return statements.length === 1 && statements[0]?.type === import_utils38.AST_NODE_TYPES.ThrowStatement;
+}
+function isTypeAssertionBranch(branch) {
+  const statements = branchStatements(branch);
+  return statements.length > 0 && statements.every(
+    (statement) => statement.type === import_utils38.AST_NODE_TYPES.ExpressionStatement && isTypeAssertionCall(statement.expression)
+  );
+}
+function isTypeLevelNarrowing(node) {
+  return isTypeAssertionBranch(node.consequent) && (node.alternate === null || isTypeAssertionBranch(node.alternate));
+}
+var isInertBranch = (branch) => !containsAssertion(branch) && !containsEscape(branch) && !containsSkipCall(branch);
+function isInertNormalization(node) {
+  return isInertBranch(node.consequent) && (node.alternate === null || isInertBranch(node.alternate));
+}
+function isExemptIfStatement(node) {
+  return isPinnedNarrowingGuard(node) || isThrowingGuard(node) || isTypeLevelNarrowing(node) || isInertNormalization(node);
+}
+function isShortCircuitedAssertion(node) {
+  return node.operator !== "??" && node.parent.type === import_utils38.AST_NODE_TYPES.ExpressionStatement && containsAssertion(node.right);
+}
+var no_conditional_in_test_default = import_utils38.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-conditional-in-test",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow conditional logic (if, switch, ternary) in test bodies, which can hide missing assertions or test multiple code paths."
     },
     schema: [],
     messages: {
@@ -5861,6 +6308,9 @@ var no_conditional_in_test_default = import_utils39.ESLintUtils.RuleCreator(
     };
     return {
       IfStatement(node) {
+        if (isExemptIfStatement(node)) {
+          return;
+        }
         report(node);
       },
       SwitchStatement(node) {
@@ -5870,6 +6320,9 @@ var no_conditional_in_test_default = import_utils39.ESLintUtils.RuleCreator(
         report(node);
       },
       LogicalExpression(node) {
+        if (!isShortCircuitedAssertion(node)) {
+          return;
+        }
         report(node);
       }
     };
@@ -5877,7 +6330,7 @@ var no_conditional_in_test_default = import_utils39.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
 var SENTINEL_WORDS = /(^|_)(SENTINEL|EMPTY|NONE|NULL|UNSET|MISSING|PLACEHOLDER|DUMMY|FAKE|EXAMPLE)(_|$)/;
@@ -5890,36 +6343,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils40.AST_NODE_TYPES.Literal:
+    case import_utils39.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils40.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils40.AST_NODE_TYPES.Identifier:
+    case import_utils39.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case import_utils40.AST_NODE_TYPES.MemberExpression:
-      return !node.computed && node.property.type === import_utils40.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case import_utils39.AST_NODE_TYPES.MemberExpression:
+      return !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils40.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils40.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils40.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils39.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -5930,7 +6383,7 @@ function secretNameOf(node) {
   }
   return operandName(node);
 }
-var prefer_constant_time_secret_compare_default = import_utils40.ESLintUtils.RuleCreator(
+var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-constant-time-secret-compare",
@@ -5973,11 +6426,11 @@ var prefer_constant_time_secret_compare_default = import_utils40.ESLintUtils.Rul
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils40 = require("@typescript-eslint/utils");
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
 var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b/i;
 var INSERT_GATE = /insert/i;
-var store_insert_requires_on_conflict_default = import_utils41.ESLintUtils.RuleCreator(
+var store_insert_requires_on_conflict_default = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "store-insert-requires-on-conflict",
@@ -6006,17 +6459,17 @@ var store_insert_requires_on_conflict_default = import_utils41.ESLintUtils.RuleC
 });
 
 // src/rules/no-dynamic-sql.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS = ["prepare", "exec", "query"];
 var CONSTANT_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
 function isStaticFragment(expression) {
-  if (expression.type === import_utils42.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.name);
   }
-  if (expression.type === import_utils42.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils42.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.property.name);
   }
-  if (expression.type === import_utils42.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.Literal) {
     return typeof expression.value === "string";
   }
   return false;
@@ -6027,36 +6480,36 @@ function runtimeInterpolations(template) {
   );
 }
 function concatOperands(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return [...concatOperands(node.left), ...concatOperands(node.right)];
   }
   return [node];
 }
 function runtimeConcatOperands(node) {
-  if (node.type !== import_utils42.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
+  if (node.type !== import_utils41.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
     return [];
   }
   const operands = concatOperands(node);
   const hasStringLiteral = operands.some(
-    (operand) => operand.type === import_utils42.AST_NODE_TYPES.Literal && typeof operand.value === "string"
+    (operand) => operand.type === import_utils41.AST_NODE_TYPES.Literal && typeof operand.value === "string"
   );
   if (!hasStringLiteral) {
     return [];
   }
   return operands.filter(
-    (operand) => operand.type !== import_utils42.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
+    (operand) => operand.type !== import_utils41.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
   );
 }
 var SQL_STATEMENT_RE = /\b(?:select\s|insert\s+into\b|insert\s+or\b|update\s+\w|delete\s+from\b|replace\s+into\b|merge\s+into\b|upsert\s+into\b|create\s+(?:temp(?:orary)?\s+)?(?:table|index|view|trigger|schema|database)\b|alter\s+table\b|drop\s+(?:table|index|view|trigger)\b|truncate\s+table\b|pragma\s+\w|with\s+\w+\s+as\s*\(|from\s+\w+\s+where\b)/i;
 var RUNTIME_MARKER = " ? ";
 function staticStatementText(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
     return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(RUNTIME_MARKER);
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils41.AST_NODE_TYPES.Literal) {
     return typeof node.value === "string" ? node.value : RUNTIME_MARKER;
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return staticStatementText(node.left) + staticStatementText(node.right);
   }
   return RUNTIME_MARKER;
@@ -6066,13 +6519,13 @@ function looksLikeSql(node) {
 }
 function statementMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils42.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils41.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
   return methods.has(name) ? name : null;
 }
-var no_dynamic_sql_default = import_utils42.ESLintUtils.RuleCreator(
+var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-dynamic-sql",
@@ -6111,7 +6564,7 @@ var no_dynamic_sql_default = import_utils42.ESLintUtils.RuleCreator(
         if (statement === void 0 || !looksLikeSql(statement)) {
           return;
         }
-        const offenders = statement.type === import_utils42.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
+        const offenders = statement.type === import_utils41.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
         for (const offender of offenders) {
           context.report({
             node: offender,
@@ -6125,7 +6578,7 @@ var no_dynamic_sql_default = import_utils42.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -6135,17 +6588,15 @@ var DEFAULT_ALLOW = [
   "[\\\\/]api[\\\\/]",
   "[\\\\/]api\\.[cm]?[jt]sx?$",
   "[-.]api\\.[cm]?[jt]sx?$",
-  "\\.test\\.",
-  "\\.spec\\.",
-  // `*.test-d.ts` type tests, and react-router's `single-fetch-test.ts` spelling.
-  "\\.(test|spec)-d\\.[cm]?[jt]sx?$",
-  "-(test|spec)\\.[cm]?[jt]sx?$",
-  "[\\\\/]__tests__[\\\\/]",
-  "[\\\\/]__mocks__[\\\\/]",
-  "[\\\\/]tests?[\\\\/]",
-  // jscodeshift input/output fixtures — text a codemod transforms, not code.
-  "[\\\\/]__testfixtures__[\\\\/]"
+  // Vendor wrapper conventions: a module that exists to own one third-party
+  // origin's HTTP. See the SECOND SWEEP note in the file header.
+  "[\\\\/]services?[\\\\/]",
+  "[\\\\/](connectors|providers|integrations|adapters|fetchers)[\\\\/]",
+  "[\\\\/]notifications[\\\\/]",
+  "[Ss]ervice\\.[cm]?[jt]sx?$",
+  "-(service|connector|adapter|sdk|fetcher)\\.[cm]?[jt]sx?$"
 ];
+var NON_PRODUCTION_TREE_RE = /[\\/](playwright|cypress|__testfixtures__)[\\/]/;
 var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -6171,6 +6622,10 @@ function identifierLikeName(node) {
   }
   return null;
 }
+function isConstructedArgumentHandoff(node) {
+  const [first] = node.arguments;
+  return node.arguments.length === 1 && first !== void 0 && first.type === import_utils42.AST_NODE_TYPES.NewExpression;
+}
 function isPresignedUrlTransfer(node) {
   const first = node.arguments[0];
   if (first === void 0) {
@@ -6189,7 +6644,7 @@ function compile(patterns) {
   }
   return compiled;
 }
-var no_raw_fetch_outside_clients_default = import_utils43.ESLintUtils.RuleCreator(
+var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-fetch-outside-clients",
@@ -6217,15 +6672,18 @@ var no_raw_fetch_outside_clients_default = import_utils43.ESLintUtils.RuleCreato
   },
   defaultOptions: [{}],
   create(context, [options]) {
+    const filename = context.filename;
+    if (isTestFile(filename) || NON_PRODUCTION_TREE_RE.test(filename)) {
+      return {};
+    }
     const patterns = options?.allow ?? DEFAULT_ALLOW;
     const allowed = compile(patterns);
-    const filename = context.filename;
     if (allowed.some((re) => re.test(filename))) {
       return {};
     }
     return {
       CallExpression(node) {
-        if (isPresignedUrlTransfer(node)) {
+        if (isPresignedUrlTransfer(node) || isConstructedArgumentHandoff(node)) {
           return;
         }
         if (isGlobalFetchCall(node)) {
@@ -6237,7 +6695,7 @@ var no_raw_fetch_outside_clients_default = import_utils43.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -6256,7 +6714,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils43.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils43.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -6268,7 +6726,7 @@ function storageMethodName(node, methods) {
   }
   return name;
 }
-var no_storage_in_stateless_modules_default = import_utils44.ESLintUtils.RuleCreator(
+var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-storage-in-stateless-modules",
@@ -6326,7 +6784,7 @@ var no_storage_in_stateless_modules_default = import_utils44.ESLintUtils.RuleCre
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS2 = [
   /[\\/]generated[\\/]/,
@@ -6344,7 +6802,7 @@ function isZodModule2(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap3(node) {
-  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils44.AST_NODE_TYPES.TSAsExpression || node.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap3(node.expression);
   }
   return node;
@@ -6352,14 +6810,14 @@ function unwrap3(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils44.AST_NODE_TYPES.Property) {
       return null;
     }
     if (prop.computed || prop.shorthand || prop.method || prop.kind !== "init") {
       return null;
     }
     const value = prop.value;
-    if (value.type !== import_utils45.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils44.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -6375,7 +6833,7 @@ function resolvesToLocalEnum(node, scope) {
     const variable = current.variables.find((v) => v.name === node.name);
     if (variable !== void 0) {
       return variable.defs.some(
-        (def) => def.node.type === import_utils45.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils44.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -6395,7 +6853,7 @@ function resolvesToImportedEnum(node, services) {
   }
   return (symbol.flags & ENUM_SYMBOL_FLAGS) !== 0;
 }
-var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
+var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-zod-native-enum",
@@ -6422,32 +6880,32 @@ var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
     }
     let services;
     try {
-      services = import_utils45.ESLintUtils.getParserServices(context);
+      services = import_utils44.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils44.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils44.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap3(arg);
-      if (inner.type !== import_utils45.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -6467,7 +6925,7 @@ var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils45.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils45.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils44.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -6486,7 +6944,7 @@ var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils44.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -6503,7 +6961,7 @@ var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils46 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS3 = [
@@ -6512,13 +6970,6 @@ var IGNORE_PATTERNS3 = [
   /\.generated\.tsx?$/,
   /\.d\.ts$/
 ];
-var TEST_FILE_PATTERNS = [
-  /\.(?:test|spec)\.[cm]?[jt]sx?$/,
-  /[\\/]__tests__[\\/]/,
-  /[\\/]__mocks__[\\/]/,
-  /[\\/]tests?[\\/]/,
-  /\.stories\.[cm]?[jt]sx?$/
-];
 var MUTATING_METHODS = /* @__PURE__ */ new Set([
   // Array
   "push",
@@ -6538,10 +6989,10 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   // Object-ish escape hatches
   "assign"
 ]);
-var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  import_utils46.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils46.AST_NODE_TYPES.FunctionExpression,
-  import_utils46.AST_NODE_TYPES.ArrowFunctionExpression
+var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
+  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils45.AST_NODE_TYPES.FunctionExpression,
+  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile3(filename, sourceText) {
@@ -6550,17 +7001,18 @@ function isIgnoredFile3(filename, sourceText) {
   }
   return /@generated\b/.test(sourceText.slice(0, 1024));
 }
-function isTestFile2(filename) {
-  return TEST_FILE_PATTERNS.some((re) => re.test(filename));
+function isLocalFixtureFile(filename) {
+  return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap4(node) {
-  if (node.type === import_utils46.AST_NODE_TYPES.TSAsExpression || node.type === import_utils46.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils46.AST_NODE_TYPES.TSNonNullExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression) {
     return unwrap4(node.expression);
   }
   return node;
 }
+var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === import_utils46.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils45.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6568,29 +7020,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap4(node);
   switch (inner.type) {
-    case import_utils46.AST_NODE_TYPES.Literal: {
-      return true;
+    case import_utils45.AST_NODE_TYPES.Literal: {
+      return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case import_utils46.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils45.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils46.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils46.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    case import_utils45.AST_NODE_TYPES.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils45.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
     }
-    case import_utils46.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils45.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils46.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils45.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils46.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils45.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils46.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils46.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils45.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6603,7 +7055,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap4(node);
-  if (inner.type === import_utils46.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils46.AST_NODE_TYPES.SpreadElement) {
+  if (inner.type === import_utils45.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils45.AST_NODE_TYPES.SpreadElement) {
     return unwrap4(inner.arguments[0]);
   }
   return inner;
@@ -6614,24 +7066,24 @@ function classify(init, checkRegex) {
     if (!checkRegex) {
       return null;
     }
-    if (/[gy]/.test(node.regex.flags)) {
+    if (HAS_STATEFUL_FLAG_RE.test(node.regex.flags)) {
       return null;
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils46.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils46.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils45.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils45.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap4(arg);
-    if (entries.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils45.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -6641,7 +7093,7 @@ function classify(init, checkRegex) {
 function enclosingFunction2(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (FUNCTION_TYPES4.has(current.type)) {
+    if (FUNCTION_TYPES5.has(current.type)) {
       return current;
     }
     current = current.parent;
@@ -6660,10 +7112,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils46.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils46.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils46.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils46.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils45.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -6677,43 +7129,43 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils46.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils46.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils46.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils46.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === import_utils45.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils45.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils46.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils46.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
 }
-var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreator(
+var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-module-level-constant",
@@ -6749,7 +7201,7 @@ var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreato
     if (isIgnoredFile3(filename, sourceCode.getText())) {
       return {};
     }
-    if (ignoreTestFiles && isTestFile2(filename)) {
+    if (ignoreTestFiles && isLocalFixtureFile(filename)) {
       return {};
     }
     function allReferencesAreSafeReads(declarator) {
@@ -6765,7 +7217,7 @@ var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreato
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils46.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6777,10 +7229,10 @@ var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreato
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils46.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils45.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils46.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6807,7 +7259,7 @@ var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreato
 });
 
 // src/rules/jsdoc-restates-signature.ts
-var import_utils47 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var VALUE_TAGS = /* @__PURE__ */ new Set([
   "alpha",
   "author",
@@ -6890,30 +7342,30 @@ function declarationNames(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
-    case import_utils47.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils47.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils46.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils46.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case import_utils47.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils47.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils46.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils46.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case import_utils47.AST_NODE_TYPES.ClassDeclaration:
-    case import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils47.AST_NODE_TYPES.TSEnumDeclaration:
+    case import_utils46.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils46.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils46.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils46.AST_NODE_TYPES.TSEnumDeclaration:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case import_utils47.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils46.AST_NODE_TYPES.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== import_utils47.AST_NODE_TYPES.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== import_utils46.AST_NODE_TYPES.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === import_utils47.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils47.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils46.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case import_utils47.AST_NODE_TYPES.MethodDefinition:
-    case import_utils47.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils47.AST_NODE_TYPES.TSMethodSignature:
-    case import_utils47.AST_NODE_TYPES.TSPropertySignature: {
-      if (node.key.type !== import_utils47.AST_NODE_TYPES.Identifier) return null;
-      const params = node.type === import_utils47.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils47.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
+    case import_utils46.AST_NODE_TYPES.MethodDefinition:
+    case import_utils46.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils46.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils46.AST_NODE_TYPES.TSPropertySignature: {
+      if (node.key.type !== import_utils46.AST_NODE_TYPES.Identifier) return null;
+      const params = node.type === import_utils46.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils46.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -6923,9 +7375,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === import_utils47.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
-    if (target.type === import_utils47.AST_NODE_TYPES.Identifier) names.push(target.name);
-    else if (target.type === import_utils47.AST_NODE_TYPES.TSParameterProperty) continue;
+    const target = param.type === import_utils46.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+    if (target.type === import_utils46.AST_NODE_TYPES.Identifier) names.push(target.name);
+    else if (target.type === import_utils46.AST_NODE_TYPES.TSParameterProperty) continue;
   }
   return names;
 }
@@ -6934,7 +7386,7 @@ function tokensOf(names) {
   for (const name of names) for (const part of splitIdentifier(name)) tokens.add(part);
   return tokens;
 }
-var jsdoc_restates_signature_default = import_utils47.ESLintUtils.RuleCreator(
+var jsdoc_restates_signature_default = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "jsdoc-restates-signature",
@@ -6970,7 +7422,7 @@ var jsdoc_restates_signature_default = import_utils47.ESLintUtils.RuleCreator(
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
           let declaration = null;
-          while (node != null && node.type !== import_utils47.AST_NODE_TYPES.Program) {
+          while (node != null && node.type !== import_utils46.AST_NODE_TYPES.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -7025,7 +7477,7 @@ var jsdoc_restates_signature_default = import_utils47.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-restated-comment.ts
-var import_utils48 = require("@typescript-eslint/utils");
+var import_utils47 = require("@typescript-eslint/utils");
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
 var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
@@ -7049,7 +7501,7 @@ function headsSiblingRun(node) {
   const next = index >= 0 ? body[index + 1] : void 0;
   return next !== void 0 && next.type === node.type;
 }
-var no_restated_comment_default = import_utils48.ESLintUtils.RuleCreator(
+var no_restated_comment_default = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-restated-comment",
@@ -7077,7 +7529,7 @@ var no_restated_comment_default = import_utils48.ESLintUtils.RuleCreator(
     function labelsASiblingRun(comment) {
       const token = sourceCode.getTokenAfter(comment, { includeComments: false });
       if (token === null) return false;
-      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils48.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils47.AST_NODE_TYPES.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -7117,7 +7569,7 @@ var no_restated_comment_default = import_utils48.ESLintUtils.RuleCreator(
 });
 
 // src/rules/trailing-value-narration.ts
-var import_utils49 = require("@typescript-eslint/utils");
+var import_utils48 = require("@typescript-eslint/utils");
 var NUMBER_RE = /(?<![\w.])(\d+(?:\.\d+)?)(?![\w.])/g;
 var WORD_RE3 = /[A-Za-z]+(?:'[a-z]+)?|\d+(?:\.\d+)?/g;
 var UNIT_WORDS = /* @__PURE__ */ new Set([
@@ -7201,7 +7653,7 @@ function narratesValue(body, code) {
     (word) => STOPWORDS3.has(word) || UNIT_WORDS.has(word) || commentNumbers.has(word) || identifiers.has(word) || stems.has(stem(word))
   );
 }
-var trailing_value_narration_default = import_utils49.ESLintUtils.RuleCreator(
+var trailing_value_narration_default = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "trailing-value-narration",
@@ -7241,6 +7693,188 @@ var trailing_value_narration_default = import_utils49.ESLintUtils.RuleCreator(
   }
 });
 
+// src/rules/no-type-member-comment-wall.ts
+var import_utils49 = require("@typescript-eslint/utils");
+var DEFAULTS = {
+  // Below three rows "a wall" is not a fair description of what the reader sees.
+  minCommentedMembers: 3,
+  // A minority of commented members is a GROUP LABEL, not a wall.
+  minCommentedRatio: 0.6,
+  // Room for one substantive row in four; a type where a quarter of the comments
+  // say something real is a type someone was documenting, not decorating.
+  minRestatedRatio: 0.75,
+  // One word beyond the member's own text. Zero is `jsdoc-restates-signature`'s
+  // test and is already covered there; two admits definitions ("Partial match"
+  // beside "Exact match"), which the evidence file counts.
+  maxNovelWords: 1
+};
+var VALUE_TAG_RE = /@(?:deprecated|see|example|throws|remarks|since|default|defaultvalue|link|internal|alpha|beta|experimental|template|typeparam|inheritdoc|todo|fixme|override)\b/i;
+var DEFAULT_RE = /^\s*@?default\b|\bdefaults? (?:to|:)/i;
+var DIGIT_RE = /\d/;
+var UNIT_WORD_RE = /\b(?:ms|milliseconds?|seconds?|minutes?|hours?|days?|weeks?|months?|years?|bytes?|kb|mb|gb|percent|pixels?|px|utc|epoch)\b/i;
+var EXAMPLE_RE = /["'`]|\be\.g\.|\bi\.e\./;
+var BANNER_RE = /[=\-─-╿*#~_.]{3,}/;
+var NON_ASCII_LETTER_RE2 = /[^\p{ASCII}\p{N}\p{P}\p{Z}]/u;
+var STOPWORDS4 = new Set(
+  `the a an of to for in on with and or as at by is are was be been being
+   this that it its if whether when where which what will would can could should
+   must may into from over about not no does do done has have had used use uses
+   using given provided specified current new existing all any each per via
+   instance object value values data item
+   items element callback handler prop props param arg return
+   returns returning result optional required true false null undefined
+   string number boolean array list promise set map record type name`.split(/\s+/)
+);
+var WORD_RE4 = /[A-Za-z][A-Za-z0-9]*/g;
+var BARE_LABEL_RE = /^[A-Za-z][A-Za-z0-9]*$/;
+function labelStems(body) {
+  return splitIdentifier(body).map(stem).join(" ");
+}
+function isNamedMember(node) {
+  return (node.type === import_utils49.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils49.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
+}
+function commentBody(comment) {
+  return comment.value.replace(/^\*+/, "").replace(/^[ \t]*\*[ \t]?/gm, "").trim();
+}
+function carriesValue(body) {
+  return isProtected(body) || VALUE_TAG_RE.test(body) || DEFAULT_RE.test(body) || DIGIT_RE.test(body) || UNIT_WORD_RE.test(body) || EXAMPLE_RE.test(body) || BANNER_RE.test(body) || NON_ASCII_LETTER_RE2.test(body);
+}
+function knownTokens(source) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const identifier of source.match(/[A-Za-z_$][\w$]*/g) ?? []) {
+    for (const part of splitIdentifier(identifier)) {
+      tokens.add(part);
+      tokens.add(stem(part));
+    }
+  }
+  return tokens;
+}
+function novelWords(body, known) {
+  let novel = 0;
+  for (const word of body.match(WORD_RE4) ?? []) {
+    const lower = word.toLowerCase();
+    if (lower.length < 2 || STOPWORDS4.has(lower)) continue;
+    if (!known.has(lower) && !known.has(stem(lower))) novel += 1;
+  }
+  return novel;
+}
+var no_type_member_comment_wall_default = import_utils49.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-type-member-comment-wall",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag an object type whose member comments mostly re-spell the members' own names and types."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          minCommentedMembers: {
+            type: "integer",
+            minimum: 2,
+            description: "Fewest commented members that can count as a wall."
+          },
+          minCommentedRatio: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "Least share of the type's members that must be commented; below it the comments are group labels."
+          },
+          minRestatedRatio: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "Least share of the member comments that must be restatements."
+          },
+          maxNovelWords: {
+            type: "integer",
+            minimum: 0,
+            description: "Most content words a comment may add beyond its member's own source and still count as a restatement."
+          }
+        }
+      }
+    ],
+    messages: {
+      commentWall: "{{restated}} of this type's {{commented}} member comments only re-spell the member's own name and type \u2014 delete them, and keep the rows that say what the name cannot."
+    }
+  },
+  defaultOptions: [DEFAULTS],
+  create(context, [provided]) {
+    const options = { ...DEFAULTS, ...provided };
+    const sourceCode = context.sourceCode;
+    if (isGeneratedFile(context.filename, sourceCode.text) || isTestFile(context.filename) || isStoryFile(context.filename)) {
+      return {};
+    }
+    const endingOn = /* @__PURE__ */ new Map();
+    const startingOn = /* @__PURE__ */ new Map();
+    for (const comment of sourceCode.getAllComments()) {
+      endingOn.set(comment.loc.end.line, comment);
+      if (!startingOn.has(comment.loc.start.line)) startingOn.set(comment.loc.start.line, comment);
+    }
+    function documentingComment(member) {
+      const beforeMember = sourceCode.getTokenBefore(member, { includeComments: false });
+      const ownsItsLine = beforeMember === null || beforeMember.loc.end.line < member.loc.start.line;
+      const lead = ownsItsLine ? endingOn.get(member.loc.start.line - 1) : void 0;
+      if (lead !== void 0) {
+        const before = sourceCode.getTokenBefore(lead, { includeComments: false });
+        if (before === null || before.loc.end.line < lead.loc.start.line) return lead;
+      }
+      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 body = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body)) return false;
+      if (labelStems(body) === 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_utils49.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
+      const named = members.filter(isNamedMember);
+      if (named.length === 0) return;
+      const documented = named.map((member) => ({ member, comment: documentingComment(member) }));
+      let commented = 0;
+      let restated = 0;
+      const claimed = /* @__PURE__ */ new Set();
+      for (const [index, { member, comment }] of documented.entries()) {
+        if (comment === void 0 || claimed.has(comment)) continue;
+        const next = documented[index + 1];
+        if (isGroupLabel(comment, member, next !== void 0 && next.comment === void 0)) {
+          continue;
+        }
+        claimed.add(comment);
+        commented += 1;
+        const body = commentBody(comment);
+        if (body.length === 0 || carriesValue(body)) continue;
+        if (novelWords(body, knownTokens(sourceCode.getText(member))) <= options.maxNovelWords) {
+          restated += 1;
+        }
+      }
+      if (commented < options.minCommentedMembers || commented / named.length < options.minCommentedRatio || restated / commented < options.minRestatedRatio) {
+        return;
+      }
+      context.report({
+        node,
+        loc: {
+          start: node.loc.start,
+          end: { line: node.loc.start.line, column: node.loc.start.column + 1 }
+        },
+        messageId: "commentWall",
+        data: { restated: String(restated), commented: String(commented) }
+      });
+    }
+    return {
+      TSInterfaceBody: check,
+      TSTypeLiteral: check
+    };
+  }
+});
+
 // src/rules/no-tautological-expect.ts
 var import_utils50 = require("@typescript-eslint/utils");
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
@@ -7580,174 +8214,217 @@ var prefer_non_nullable_collection_default = import_utils52.ESLintUtils.RuleCrea
   }
 });
 
-// src/rules/no-implicit-attribute-access.ts
+// src/rules/strict-test-assertions.ts
 var import_utils53 = require("@typescript-eslint/utils");
-var EXCLUDED_BASES = /* @__PURE__ */ new Set([
-  "environ",
-  "headers",
-  "cookies",
-  "session",
-  "redis",
-  "cache",
-  "state",
-  "config",
-  "env",
-  "process",
-  "localStorage",
-  "sessionStorage"
-]);
-function getBaseName(node) {
-  if (node.type === import_utils53.AST_NODE_TYPES.Identifier) {
-    return node.name;
+var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var ARRAY_MATCHERS = /* @__PURE__ */ new Set(["toEqual", "toStrictEqual"]);
+var COLLECTION_PROPERTIES = /* @__PURE__ */ new Set(["length", "size"]);
+var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
+var MIN_RUN_LENGTH = 2;
+function literalText(node, getText) {
+  switch (node.type) {
+    case import_utils53.AST_NODE_TYPES.Literal:
+      return "regex" in node ? null : getText(node);
+    case import_utils53.AST_NODE_TYPES.TemplateLiteral:
+      return node.expressions.length === 0 ? getText(node) : null;
+    case import_utils53.AST_NODE_TYPES.UnaryExpression:
+      return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
+    default:
+      return null;
   }
-  if (node.type === import_utils53.AST_NODE_TYPES.MemberExpression && node.property.type === import_utils53.AST_NODE_TYPES.Identifier) {
-    return node.property.name;
+}
+function isPureReceiver(node) {
+  switch (node.type) {
+    case import_utils53.AST_NODE_TYPES.Identifier:
+    case import_utils53.AST_NODE_TYPES.ThisExpression:
+      return true;
+    case import_utils53.AST_NODE_TYPES.MemberExpression:
+      if (node.optional) {
+        return false;
+      }
+      if (node.computed) {
+        return node.property.type === import_utils53.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+      }
+      return isPureReceiver(node.object);
+    default:
+      return false;
   }
-  return null;
 }
-var no_implicit_attribute_access_default = import_utils53.ESLintUtils.RuleCreator(
+function literalIndex(node) {
+  if (node.type !== import_utils53.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+    return null;
+  }
+  return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
+}
+var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
-  name: "no-implicit-attribute-access",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow imperative dictionary access with string literals; use declarative Zod schemas."
-    },
-    schema: [],
-    messages: {
-      noImplicitAttributeAccess: "Imperative lookup for '{{key}}' \u2014 if the key is known, parse the object declaratively with a Zod schema instead."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      MemberExpression(node) {
-        if (!node.computed) {
-          return;
-        }
-        if (node.property.type === import_utils53.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
-          const baseName = getBaseName(node.object);
-          if (!baseName || !EXCLUDED_BASES.has(baseName)) {
-            context.report({
-              node,
-              messageId: "noImplicitAttributeAccess",
-              data: { key: node.property.value }
-            });
-          }
-        }
-      },
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee.type === import_utils53.AST_NODE_TYPES.MemberExpression) {
-          const method = callee.property.type === import_utils53.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-          if (method === "get") {
-            const arg = node.arguments[0];
-            if (arg && arg.type === import_utils53.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
-              const baseName = getBaseName(callee.object);
-              if (!baseName || !EXCLUDED_BASES.has(baseName)) {
-                context.report({
-                  node,
-                  messageId: "noImplicitAttributeAccess",
-                  data: { key: arg.value }
-                });
-              }
-            }
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/rules/strict-test-assertions.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var strict_test_assertions_default = import_utils54.ESLintUtils.RuleCreator.withoutDocs({
+  name: "strict-test-assertions",
   meta: {
     type: "suggestion",
     docs: {
-      description: "Replace multiple sequential assertions with a single toMatchObject or toStrictEqual"
+      description: "Collapse a run of consecutive assertions on the same object into one assertion about the whole object, so every mismatch is reported and nothing outside the asserted keys goes unchecked."
     },
     fixable: "code",
     messages: {
-      combineAssertions: "Combine multiple sequential assertions on the same object into a single toMatchObject or toStrictEqual"
+      combineAssertions: "These {{count}} assertions each check one property of `{{receiver}}` against a literal, so the first mismatch hides the rest. Assert the object once: `expect({{receiver}}).toMatchObject({ \u2026 })`.",
+      assertArrayOnce: "These {{count}} assertions check `{{receiver}}[0]`\u2026`{{receiver}}[{{last}}]` one at a time, which never checks how long `{{receiver}}` is \u2014 extra elements pass unnoticed. Assert the array once: `expect({{receiver}}).{{matcher}}([ \u2026 ])`."
     },
     schema: []
   },
   defaultOptions: [],
   create(context) {
-    function checkBody(body) {
-      let currentObject = null;
-      let sequence = [];
-      function getExpectObject(expr) {
-        if (expr.type === import_utils54.AST_NODE_TYPES.CallExpression && expr.callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && expr.callee.object.type === import_utils54.AST_NODE_TYPES.CallExpression && expr.callee.object.callee.type === import_utils54.AST_NODE_TYPES.Identifier && expr.callee.object.callee.name === "expect" && expr.callee.object.arguments.length === 1) {
-          const arg = expr.callee.object.arguments.at(0);
-          if (arg?.type === import_utils54.AST_NODE_TYPES.MemberExpression) {
-            return arg.object;
-          }
+    if (!isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    const { sourceCode } = context;
+    function parseAssertion(statement) {
+      if (statement.type !== import_utils53.AST_NODE_TYPES.ExpressionStatement) {
+        return null;
+      }
+      const call = statement.expression;
+      if (call.type !== import_utils53.AST_NODE_TYPES.CallExpression) {
+        return null;
+      }
+      const callee = call.callee;
+      if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier) {
+        return null;
+      }
+      const matcher = callee.property.name;
+      const expectCall = callee.object;
+      if (expectCall.type !== import_utils53.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils53.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+        return null;
+      }
+      const actual = expectCall.arguments[0];
+      if (actual === void 0 || actual.type !== import_utils53.AST_NODE_TYPES.MemberExpression || actual.optional) {
+        return null;
+      }
+      if (!isPureReceiver(actual.object)) {
+        return null;
+      }
+      let key;
+      if (actual.computed) {
+        const index = literalIndex(actual.property);
+        if (index === null) {
+          return null;
+        }
+        key = { kind: "index", index };
+      } else {
+        if (actual.property.type !== import_utils53.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name)) {
+          return null;
         }
+        key = { kind: "property", name: actual.property.name };
+      }
+      if (matcher === "toBeNull" && call.arguments.length === 0) {
+        return { statement, receiver: actual.object, key, matcher, expectedText: "null", expectedIsLiteral: true };
+      }
+      if (!MERGEABLE_MATCHERS.has(matcher)) {
         return null;
       }
-      function reportSequence() {
-        const first = sequence.at(0);
-        if (sequence.length > 1 && first) {
-          context.report({
-            node: first,
-            messageId: "combineAssertions",
-            fix(fixer) {
-              if (!currentObject) return null;
-              const objectText = context.sourceCode.getText(currentObject);
-              const props = sequence.map((stmt) => {
-                if (stmt.expression.type !== import_utils54.AST_NODE_TYPES.CallExpression || stmt.expression.callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || stmt.expression.callee.object.type !== import_utils54.AST_NODE_TYPES.CallExpression) {
-                  return null;
-                }
-                const actual = stmt.expression.callee.object.arguments.at(0);
-                const expected = stmt.expression.arguments.at(0);
-                if (actual?.type === import_utils54.AST_NODE_TYPES.MemberExpression && actual.property.type === import_utils54.AST_NODE_TYPES.Identifier && expected) {
-                  const propName2 = actual.property.name;
-                  const valText = context.sourceCode.getText(expected);
-                  return `${propName2}: ${valText}`;
-                }
-                return null;
-              });
-              if (props.some((p) => p === null)) return null;
-              const replacement = `expect(${objectText}).toMatchObject({ ${props.join(", ")} });`;
-              return [
-                fixer.replaceText(first, replacement),
-                ...sequence.slice(1).map((stmt) => fixer.remove(stmt))
-              ];
-            }
-          });
+      const expected = call.arguments[0];
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils53.AST_NODE_TYPES.SpreadElement) {
+        return null;
+      }
+      const literal = literalText(expected, (node) => sourceCode.getText(node));
+      return {
+        statement,
+        receiver: actual.object,
+        key,
+        matcher,
+        expectedText: literal ?? sourceCode.getText(expected),
+        expectedIsLiteral: literal !== null
+      };
+    }
+    function reportPropertyRun(run) {
+      const names = /* @__PURE__ */ new Set();
+      for (const assertion of run) {
+        if (assertion.key.kind !== "property" || !assertion.expectedIsLiteral) {
+          return;
+        }
+        if (!MERGEABLE_MATCHERS.has(assertion.matcher) && assertion.matcher !== "toBeNull") {
+          return;
+        }
+        if (names.has(assertion.key.name)) {
+          return;
         }
+        names.add(assertion.key.name);
       }
-      for (const statement of body) {
-        if (statement.type === import_utils54.AST_NODE_TYPES.ExpressionStatement) {
-          const obj = getExpectObject(statement.expression);
-          if (obj && currentObject && context.sourceCode.getText(obj) === context.sourceCode.getText(currentObject)) {
-            sequence.push(statement);
+      const first = run[0];
+      if (first === void 0) {
+        return;
+      }
+      const receiverText = sourceCode.getText(first.receiver);
+      const properties = run.map(
+        (assertion) => assertion.key.kind === "property" ? `${assertion.key.name}: ${assertion.expectedText}` : ""
+      ).join(", ");
+      context.report({
+        node: first.statement,
+        messageId: "combineAssertions",
+        data: { count: String(run.length), receiver: receiverText },
+        fix: (fixer) => [
+          fixer.replaceText(first.statement, `expect(${receiverText}).toMatchObject({ ${properties} });`),
+          ...run.slice(1).map((assertion) => fixer.remove(assertion.statement))
+        ]
+      });
+    }
+    function reportIndexRun(run) {
+      const first = run[0];
+      if (first === void 0 || !ARRAY_MATCHERS.has(first.matcher)) {
+        return;
+      }
+      const indices = /* @__PURE__ */ new Set();
+      for (const assertion of run) {
+        if (assertion.key.kind !== "index" || assertion.matcher !== first.matcher) {
+          return;
+        }
+        indices.add(assertion.key.index);
+      }
+      if (indices.size !== run.length || Math.max(...indices) !== run.length - 1) {
+        return;
+      }
+      context.report({
+        node: first.statement,
+        messageId: "assertArrayOnce",
+        data: {
+          count: String(run.length),
+          receiver: sourceCode.getText(first.receiver),
+          last: String(run.length - 1),
+          matcher: first.matcher
+        }
+      });
+    }
+    function checkBody(body) {
+      let run = [];
+      const flush = () => {
+        const first = run[0];
+        if (first !== void 0 && run.length >= MIN_RUN_LENGTH) {
+          if (first.key.kind === "property") {
+            reportPropertyRun(run);
           } else {
-            reportSequence();
-            if (obj) {
-              currentObject = obj;
-              sequence = [statement];
-            } else {
-              currentObject = null;
-              sequence = [];
-            }
+            reportIndexRun(run);
           }
-        } else {
-          reportSequence();
-          currentObject = null;
-          sequence = [];
+        }
+        run = [];
+      };
+      for (const statement of body) {
+        const assertion = parseAssertion(statement);
+        const previous = run.at(-1);
+        if (assertion !== null && previous !== void 0 && previous.key.kind === assertion.key.kind && sourceCode.getText(previous.receiver) === sourceCode.getText(assertion.receiver)) {
+          run.push(assertion);
+          continue;
+        }
+        flush();
+        if (assertion !== null) {
+          run = [assertion];
         }
       }
-      reportSequence();
+      flush();
     }
     return {
-      BlockStatement(node) {
+      BlockStatement: (node) => {
         checkBody(node.body);
       },
-      Program(node) {
+      Program: (node) => {
         checkBody(node.body);
       }
     };
@@ -7755,8 +8432,8 @@ var strict_test_assertions_default = import_utils54.ESLintUtils.RuleCreator.with
 });
 
 // src/rules/no-async-callback-in-waitfor.ts
-var import_utils55 = require("@typescript-eslint/utils");
-var no_async_callback_in_waitfor_default = import_utils55.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var no_async_callback_in_waitfor_default = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-async-callback-in-waitfor",
@@ -7777,9 +8454,9 @@ var no_async_callback_in_waitfor_default = import_utils55.ESLintUtils.RuleCreato
     }
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils55.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
+        if (node.callee.type === import_utils54.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
           const callback = node.arguments[0];
-          if (callback && (callback.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils55.AST_NODE_TYPES.FunctionExpression) && callback.async) {
+          if (callback && (callback.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils54.AST_NODE_TYPES.FunctionExpression) && callback.async) {
             context.report({
               node: callback,
               messageId: "noAsyncCallbackInWaitFor"
@@ -7792,7 +8469,7 @@ var no_async_callback_in_waitfor_default = import_utils55.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-hand-rolled-sleep.ts
-var import_utils56 = require("@typescript-eslint/utils");
+var import_utils55 = require("@typescript-eslint/utils");
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -7811,66 +8488,66 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function isSetTimeoutCallee(callee) {
-  if (callee.type === import_utils56.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils55.AST_NODE_TYPES.Identifier) {
     return callee.name === "setTimeout";
   }
-  return callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && callee.property.name === "setTimeout" && callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name);
+  return callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && callee.property.name === "setTimeout" && callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name);
 }
 function soleCall(fn) {
-  if (fn.body.type !== import_utils56.AST_NODE_TYPES.BlockStatement) {
-    return fn.body.type === import_utils56.AST_NODE_TYPES.CallExpression ? fn.body : null;
+  if (fn.body.type !== import_utils55.AST_NODE_TYPES.BlockStatement) {
+    return fn.body.type === import_utils55.AST_NODE_TYPES.CallExpression ? fn.body : null;
   }
   if (fn.body.body.length !== 1) {
     return null;
   }
   const [only] = fn.body.body;
-  if (only?.type !== import_utils56.AST_NODE_TYPES.ExpressionStatement) {
+  if (only?.type !== import_utils55.AST_NODE_TYPES.ExpressionStatement) {
     return null;
   }
-  return only.expression.type === import_utils56.AST_NODE_TYPES.CallExpression ? only.expression : null;
+  return only.expression.type === import_utils55.AST_NODE_TYPES.CallExpression ? only.expression : null;
 }
 function isTimedDelay(delay) {
   if (delay === void 0) {
     return false;
   }
-  if (delay.type === import_utils56.AST_NODE_TYPES.Literal && typeof delay.value === "number") {
+  if (delay.type === import_utils55.AST_NODE_TYPES.Literal && typeof delay.value === "number") {
     return delay.value !== 0;
   }
   return true;
 }
 function settlesWithoutValue(callback, name) {
-  if (callback.type === import_utils56.AST_NODE_TYPES.Identifier) {
+  if (callback.type === import_utils55.AST_NODE_TYPES.Identifier) {
     return callback.name === name;
   }
-  if (callback.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
+  if (callback.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const call = soleCall(callback);
-  return call !== null && call.arguments.length === 0 && call.callee.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.name === name;
+  return call !== null && call.arguments.length === 0 && call.callee.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.name === name;
 }
 function rejectsInCallback(callback, name) {
-  if (callback.type === import_utils56.AST_NODE_TYPES.Identifier) {
+  if (callback.type === import_utils55.AST_NODE_TYPES.Identifier) {
     return callback.name === name;
   }
-  if (callback.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
+  if (callback.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const call = soleCall(callback);
-  return call !== null && call.callee.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.name === name;
+  return call !== null && call.callee.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.name === name;
 }
 function parameterName(fn, index) {
   const parameter = fn.params[index];
-  return parameter?.type === import_utils56.AST_NODE_TYPES.Identifier ? parameter.name : null;
+  return parameter?.type === import_utils55.AST_NODE_TYPES.Identifier ? parameter.name : null;
 }
 function isRaceArm(node) {
   const array = node.parent;
-  if (array?.type !== import_utils56.AST_NODE_TYPES.ArrayExpression) {
+  if (array?.type !== import_utils55.AST_NODE_TYPES.ArrayExpression) {
     return false;
   }
   const call = array.parent;
-  return call?.type === import_utils56.AST_NODE_TYPES.CallExpression && call.arguments[0] === array && call.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.object.name === "Promise" && call.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && RACE_METHODS.has(call.callee.property.name);
+  return call?.type === import_utils55.AST_NODE_TYPES.CallExpression && call.arguments[0] === array && call.callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.object.name === "Promise" && call.callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && RACE_METHODS.has(call.callee.property.name);
 }
-var no_hand_rolled_sleep_default = import_utils56.ESLintUtils.RuleCreator(
+var no_hand_rolled_sleep_default = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-hand-rolled-sleep",
@@ -7918,10 +8595,10 @@ var no_hand_rolled_sleep_default = import_utils56.ESLintUtils.RuleCreator(
       }
       const program = sourceCode.ast;
       for (const statement of program.body) {
-        if (statement.type === import_utils56.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils56.AST_NODE_TYPES.Literal && statement.expression.value === "use client") {
+        if (statement.type === import_utils55.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils55.AST_NODE_TYPES.Literal && statement.expression.value === "use client") {
           return true;
         }
-        if (statement.type === import_utils56.AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && CLIENT_ONLY_MODULES.test(statement.source.value)) {
+        if (statement.type === import_utils55.AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && CLIENT_ONLY_MODULES.test(statement.source.value)) {
           return true;
         }
       }
@@ -7937,11 +8614,11 @@ var no_hand_rolled_sleep_default = import_utils56.ESLintUtils.RuleCreator(
     };
     return {
       NewExpression(node) {
-        if (node.callee.type !== import_utils56.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+        if (node.callee.type !== import_utils55.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
           return;
         }
         const executor = node.arguments[0];
-        if (executor?.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
+        if (executor?.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const call = soleCall(executor);
@@ -7968,43 +8645,8 @@ var no_hand_rolled_sleep_default = import_utils56.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/prefer-setup-file-mocks.ts
-var import_utils57 = require("@typescript-eslint/utils");
-var prefer_setup_file_mocks_default = import_utils57.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "prefer-setup-file-mocks",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer defining module mocks in setup files rather than using vi.mock or jest.mock inline in test files."
-    },
-    schema: [],
-    messages: {
-      preferSetupFileMocks: "Define module mocks in a setup file (e.g. vitest.setup.ts) instead of using vi.mock or jest.mock directly in test files."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (!isTestFile(context.filename)) {
-      return {};
-    }
-    return {
-      CallExpression(node) {
-        if (node.callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils57.AST_NODE_TYPES.Identifier && (node.callee.object.name === "vi" || node.callee.object.name === "jest") && node.callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && node.callee.property.name === "mock") {
-          context.report({
-            node,
-            messageId: "preferSetupFileMocks"
-          });
-        }
-      }
-    };
-  }
-});
-
 // src/index.ts
 var rules = {
-  "ban-loose-type-guards-in-tests": ban_loose_type_guards_in_tests_default,
   "enforce-file-structure": enforce_file_structure_default,
   "no-client-side-data-fetching": no_client_side_data_fetching_default,
   "no-comment-cruft": no_comment_cruft_default,
@@ -8049,18 +8691,17 @@ var rules = {
   "jsdoc-restates-signature": jsdoc_restates_signature_default,
   "no-restated-comment": no_restated_comment_default,
   "trailing-value-narration": trailing_value_narration_default,
+  "no-type-member-comment-wall": no_type_member_comment_wall_default,
   "no-tautological-expect": no_tautological_expect_default,
   "require-interface-for-injected-service": require_interface_for_injected_service_default,
   "strict-test-assertions": strict_test_assertions_default,
   "prefer-non-nullable-collection": prefer_non_nullable_collection_default,
-  "no-implicit-attribute-access": no_implicit_attribute_access_default,
-  "no-async-callback-in-waitfor": no_async_callback_in_waitfor_default,
-  "prefer-setup-file-mocks": prefer_setup_file_mocks_default
+  "no-async-callback-in-waitfor": no_async_callback_in_waitfor_default
 };
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "4.2.0"
+    version: "5.1.0"
   },
   rules,
   configs: {
@@ -8070,7 +8711,6 @@ var plugin = {
         "@sarj/zod-naming-convention": "warn",
         "@sarj/require-assert-never": "error",
         "@sarj/require-zod-form-validation": "error",
-        "@sarj/ban-loose-type-guards-in-tests": "error",
         "@sarj/enforce-file-structure": "warn",
         "@sarj/no-client-side-data-fetching": "warn",
         "@sarj/prefer-server-actions": "warn",
@@ -8141,6 +8781,14 @@ var plugin = {
         "@sarj/no-restated-comment": "warn",
         "@sarj/jsdoc-restates-signature": "warn",
         "@sarj/trailing-value-narration": "warn",
+        // The VOLUME arm of the same family (2026-07). Its siblings judge one
+        // comment at a time and can only condemn one that adds nothing; this
+        // one judges a TYPE, so it can report ten rows that each add a word.
+        // 33 OSS TS repos / 46,861 files: 22 findings, all read, 0 false; zero
+        // across ten first-party repos, where the generated-file sniff alone
+        // removed 321 of the 407 raw hits. Measurements and the six false
+        // positives that shaped the guards: docs/rules/no-type-member-comment-wall.md
+        "@sarj/no-type-member-comment-wall": "warn",
         // The TS half of SARJ057 (2026-07). Python has caught the
         // assertion-FREE test since 0.15.0 (SARJ043) and had no TS
         // counterpart, which is how `expect(true).toBe(true); // placeholder`
@@ -8155,9 +8803,7 @@ var plugin = {
         // port, 29 fire, 28 of them true positives.
         "@sarj/require-interface-for-injected-service": "warn",
         "@sarj/prefer-non-nullable-collection": "warn",
-        "@sarj/no-implicit-attribute-access": "warn",
-        "@sarj/no-async-callback-in-waitfor": "warn",
-        "@sarj/prefer-setup-file-mocks": "warn"
+        "@sarj/no-async-callback-in-waitfor": "warn"
       }
     },
     strict: {
@@ -8166,7 +8812,6 @@ var plugin = {
         "@sarj/zod-naming-convention": "error",
         "@sarj/require-assert-never": "error",
         "@sarj/require-zod-form-validation": "error",
-        "@sarj/ban-loose-type-guards-in-tests": "error",
         "@sarj/enforce-file-structure": "error",
         "@sarj/no-raw-env": "error",
         "@sarj/no-enum": "error",
@@ -8234,6 +8879,7 @@ var plugin = {
         "@sarj/no-restated-comment": "error",
         "@sarj/jsdoc-restates-signature": "error",
         "@sarj/trailing-value-narration": "error",
+        "@sarj/no-type-member-comment-wall": "error",
         // TS half of SARJ057 — see the `recommended` block for the measurement.
         "@sarj/no-tautological-expect": "error",
         // Substitutability: the TS sibling of the Python `prefer-real-store-in-tests`
@@ -8241,9 +8887,7 @@ var plugin = {
         // corpus (175 `implements` clauses vs 29 hits), so strict enforces it.
         "@sarj/require-interface-for-injected-service": "error",
         "@sarj/prefer-non-nullable-collection": "error",
-        "@sarj/no-implicit-attribute-access": "error",
-        "@sarj/no-async-callback-in-waitfor": "error",
-        "@sarj/prefer-setup-file-mocks": "error"
+        "@sarj/no-async-callback-in-waitfor": "error"
       }
     }
   }