@sarj/eslint-plugin 2.12.2 → 2.14.0

package/dist/index.cjs

@@ -276,56 +276,90 @@ var no_client_side_data_fetching_default = import_utils2.ESLintUtils.RuleCreator
 });
 
 // src/rules/no-comment-cruft.ts
+var import_utils4 = require("@typescript-eslint/utils");
+
+// src/rules/_comments.ts
 var import_utils3 = require("@typescript-eslint/utils");
-var LEADING_PREAMBLE_MIN = 4;
-var STEP_NARRATION_RE = /^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|after(?:wards| that)?|finally|lastly|now)\s*[,:]\s*\S|^step\s+\d+\b/i;
-var META_COMMENTARY_RE = /\b(?:for now|keeping (?:it|this) simple|could be (?:refactored|improved|cleaned up|simplified)|refactor(?:ed|ing)? (?:later|this)|not sure (?:if|whether|why|how)|quick[- ](?:and[- ]dirty|fix)|(?:a |bit of a )?hacky|is a hack|temporary (?:solution|workaround|fix|hack)|revisit (?:this|later|below)|clean (?:this|it) up|not ideal|placeholder for now)\b/i;
-var DIRECTIVE_RE = /^(eslint\b|eslint-|@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;
-var LICENSE_RE = /copyright|licen[cs]ed?|spdx|permission is hereby granted|all rights reserved/i;
-var ENUMERATED_ITEM_RE = /^(?:\d+[.):]|[-*•])\s+\S/;
-var ENUMERATED_ITEM_MIN_WORDS = 3;
-var ENUMERATED_PREAMBLE_MIN_ITEMS = 2;
-var BANNER_FULL_RE = /^[\s\-=*#~_+.]{4,}$/;
-var BANNER_RUN_RE = /={4,}|-{4,}|#{4,}|\*{4,}|~{4,}/;
-var REGION_RE = /^#?(?:end)?region\b/i;
-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 PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
-function stripCommentMarker(line) {
-  return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
-}
-function isDirective(text) {
-  return DIRECTIVE_RE.test(text.trim());
-}
-function isBanner(text) {
-  const t = text.trim();
-  if (!t) return false;
-  if (BANNER_FULL_RE.test(t) || REGION_RE.test(t)) return true;
-  return BANNER_RUN_RE.test(t) && !DIAGRAM_ARROW_RE.test(t);
-}
-function looksLikeCode(text) {
-  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);
+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/;
+var CAUSAL_RE = /\b(?:because|otherwise|so that|or else|would (?:break|fail|race|deadlock|leak|clobber|loop|crash|page|stall)|breaks?\b|so we don'?t|to avoid\b|caused\b|causes\b|gets? clobbered|keeps? (?:us|it|them) from|doesn'?t\b.{0,24}\b(?:page|fire|break|leak|loop)|eat into|would otherwise|trade-?offs?\b)\b/i;
+var NEGATION_RE = /\b(?:must not|must never|do(?:es)? not\b|don'?t\b.{0,30}\b(?:leak|log|cache|retry|block|steal|wipe)|never\b|deliberately|intentionally|counterintuitiv|NOT\b)|(?<!based )\bon purpose\b|\(not\s|\binstead of\b|\brather than\b/;
+var UPSTREAM_RE = /\b(?:upstream|workaround|quirk|backport|vendored|regression|fixed upstream|requires?\b|convention\b|rate.?limit|deprecat|opts? in(?:to)?\b|raises?\b.{0,60}\b(?:when|if|unless)\b)/i;
+var INVARIANT_RE = /\b(?:invariant|idempotent|race\b|deadlock|re-?entran|atomic|thread-?safe|signal-?safe|lexicographic(?:al(?:ly)?)?|monotonic|must (?:run|be|happen|come|stay|hit|converge|configure)|before any\b|lost the (?:claim )?race)\b/i;
+var SECURITY_RE = /\b(?:timing attack|constant-?time|replay|PII\b|redact|secret|injection|spoof|fail-?closed|fail-?open|auth bypass|early-?exit timing)\b/i;
+var VENDOR_RE = /\b(?:GitHub|Slack|Twilio|LiveKit|Kamailio|Groq|OpenAI|Anthropic|Cloudflare|FastAPI|Starlette|Sentry|Zoho|Salla|Ashby|Linear|BigQuery|Postgres|Neon|Drizzle|Vertex|Gemini|Firestore|Stripe|Next\.js|React Compiler|pydantic|ruff|loguru|Lexical|Farasa|Orpheus|Whisper|schemathesis)(?:'s\b|\s+(?:requires?|returns?|expects?|allows?|rejects?|accepts?|sends?|caps?|limits?|wraps?|silently|outputs?|stores?|treats?|doesn'?t|does not|won'?t|can'?t|only|models)\b)/;
+var PROTECTED_SIGNALS = [
+  REF_RE,
+  VERSION_RE,
+  UNITS_RE,
+  CAUSAL_RE,
+  NEGATION_RE,
+  UPSTREAM_RE,
+  INVARIANT_RE,
+  SECURITY_RE,
+  VENDOR_RE
+];
+function isProtected(body) {
+  return PROTECTED_SIGNALS.some((signal) => signal.test(body));
+}
+function hasExternalReference(body) {
+  return REF_RE.test(body);
+}
+var STOPWORDS = new Set(
+  `a an the this that these those it its their his her our your my
+   is are was were be been being am do does did done doing has have had having
+   will would shall should can could may might must
+   and or but nor so yet not no none
+   to of for in on at by with from into onto out up down over under about
+   as if then than when where which who whom whose what how why while
+   we you they i he she them him us me
+   also just only even still already again there here
+   all any each every some
+   via per etc eg ie vs
+   need needs needed want wants make makes making let lets
+   please note see above below`.split(/\s+/)
+);
+var CAMEL_PART_RE = /[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+/g;
+var WORD_RE = /[A-Za-z_$][\w$]*|\d+/g;
+function splitIdentifier(token) {
+  const parts = [];
+  for (const chunk of token.split(/[_$]/)) {
+    for (const match of chunk.match(CAMEL_PART_RE) ?? []) {
+      parts.push(match.toLowerCase());
+    }
+  }
+  return parts;
 }
-function hasPseudocode(text) {
-  return PSEUDOCODE_RE.test(text);
+function stem(word) {
+  let base = word;
+  for (const suffix of ["ing", "ied", "ies", "ers", "er", "ed", "es", "s"]) {
+    if (word.endsWith(suffix) && word.length - suffix.length >= 3) {
+      base = word.slice(0, word.length - suffix.length);
+      if (suffix === "ied" || suffix === "ies") return `${base}y`;
+      break;
+    }
+  }
+  return base.endsWith("e") && base.length - 1 >= 3 ? base.slice(0, -1) : base;
 }
-function isEnumeratedProseItem(text) {
-  const t = text.trim();
-  return ENUMERATED_ITEM_RE.test(t) && t.split(/\s+/).length >= ENUMERATED_ITEM_MIN_WORDS;
+function contentTokens(text) {
+  const tokens = [];
+  for (const match of text.match(WORD_RE) ?? []) {
+    tokens.push(...splitIdentifier(match));
+  }
+  return tokens.filter((token) => !STOPWORDS.has(token));
 }
-function isProse(text) {
-  const t = text.trim();
-  if (!t) return false;
-  if (t.endsWith(":")) return true;
-  if (/[.!?]$/.test(t) && /\s/.test(t) && /[a-z]/.test(t) && !looksLikeCode(t) && t.split(/\s+/).length >= 3) {
-    return true;
+function codeTokens(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const match of text.match(WORD_RE) ?? []) {
+    for (const part of splitIdentifier(match)) tokens.add(part);
   }
-  return false;
+  return tokens;
+}
+function restates(commentTokens, code) {
+  const stems = /* @__PURE__ */ new Set();
+  for (const token of code) stems.add(stem(token));
+  return commentTokens.every((token) => code.has(token) || stems.has(stem(token)));
 }
 var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
@@ -386,7 +420,7 @@ function normalizeToken(word) {
   const lower = word.toLowerCase();
   return lower.length > TOKEN_PLURAL_MIN && lower.endsWith("s") && !lower.endsWith("ss") ? lower.slice(0, -1) : lower;
 }
-function codeTokens(source) {
+function headTokens(source) {
   const tokens = /* @__PURE__ */ new Set();
   for (const identifier of source.match(/[A-Za-z_$][\w$]*/g) ?? []) {
     tokens.add(normalizeToken(identifier));
@@ -418,7 +452,7 @@ function restatableStatementBelow(comment, sourceCode) {
   }
   return null;
 }
-function restatesNextLine(body, statement) {
+function restatesStatementHead(body, statement) {
   if (statement === null) return false;
   const words = body.match(/[A-Za-z][\w$]*/g) ?? [];
   const opener = words[0];
@@ -427,18 +461,152 @@ function restatesNextLine(body, statement) {
   const content = words.slice(1).map(normalizeToken).filter((word) => !NARRATION_STOPWORDS.has(word));
   if (content.length < NARRATION_MIN_CONTENT) return false;
   const head = statement.split("(")[0] ?? statement;
-  const code = codeTokens(head);
+  const code = headTokens(head);
   return content.every((word) => code.has(word));
 }
+
+// src/rules/no-comment-cruft.ts
+var LEADING_PREAMBLE_MIN = 4;
+var STEP_NARRATION_RE = /^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|after(?:wards| that)?|finally|lastly|now)\s*[,:]\s*\S|^step\s+\d+\b/i;
+var META_COMMENTARY_RE = /\b(?:for now|keeping (?:it|this) simple|could be (?:refactored|improved|cleaned up|simplified)|refactor(?:ed|ing)? (?:later|this)|not sure (?:if|whether|why|how)|quick[- ](?:and[- ]dirty|fix)|(?:a |bit of a )?hacky|is a hack|temporary (?:solution|workaround|fix|hack)|revisit (?:this|later|below)|clean (?:this|it) up|not ideal|placeholder for now)\b/i;
+var DIRECTIVE_RE = /^(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;
+var LICENSE_RE = /copyright|licen[cs]ed?|spdx|permission is hereby granted|all rights reserved/i;
+var ENUMERATED_ITEM_RE = /^(?:\d+[.):]|[-*•])\s+\S/;
+var ENUMERATED_ITEM_MIN_WORDS = 3;
+var ENUMERATED_PREAMBLE_MIN_ITEMS = 2;
+var BANNER_FULL_RE = /^[\s\-=*#~_+.]{4,}$/;
+var BANNER_RUN_RE = /={4,}|-{4,}|#{4,}|\*{4,}|~{4,}|[\u2500-\u257f]{4,}/;
+var REGION_MARKER_RE = /^#?(?:end)?region\b(.*)$/i;
+var REGION_TITLE_RE = /^[\s:\-\u2013\u2014]*\w[\w \-/&+]*$/;
+var REGION_TITLE_MAX_WORDS = 5;
+function isRegionMarker(text) {
+  const match = REGION_MARKER_RE.exec(text);
+  if (match === null) return false;
+  const title = (match[1] ?? "").trim();
+  if (title.length === 0) return true;
+  if (!REGION_TITLE_RE.test(title)) return false;
+  return title.split(/\s+/).length <= REGION_TITLE_MAX_WORDS;
+}
+var SECTION_LABEL_WORDS = /* @__PURE__ */ new Set([
+  "actions",
+  "components",
+  "config",
+  "configuration",
+  "constant",
+  "constants",
+  "enums",
+  "exports",
+  "fixtures",
+  "getters",
+  "globals",
+  "handler",
+  "handlers",
+  "helper",
+  "helpers",
+  "hook",
+  "hooks",
+  "imports",
+  "interfaces",
+  "main",
+  "mocks",
+  "models",
+  "mutations",
+  "props",
+  "queries",
+  "reducers",
+  "routes",
+  "schemas",
+  "selectors",
+  "setters",
+  "setup",
+  "state",
+  "styles",
+  "teardown",
+  "type",
+  "types",
+  "util",
+  "utilities",
+  "utils"
+]);
+var SECTION_LABEL_RE = /^([A-Za-z]+)\s*:?\s*$/;
+function isSectionLabel(text) {
+  const match = SECTION_LABEL_RE.exec(text);
+  return match !== null && SECTION_LABEL_WORDS.has((match[1] ?? "").toLowerCase());
+}
+var HELPER_OPENER_RE = /^(?:a\s+)?helper\s+(?:function|method|component|hook|class|type|util(?:ity)?)\b/i;
+var LETS_RE = /^let'?s\s+(?:not\s+|just\s+|now\s+|first\s+)?(?:add|append|assign|await|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|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|ed|ing)?\b/i;
+var ENUMERATION_RE = /^(?:\d+[.)]\s+\S|phase\s+\d+\b)/i;
+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 PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
+function stripCommentMarker(line) {
+  return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
+}
+function isDirective(text) {
+  return DIRECTIVE_RE.test(text.trim());
+}
+function isBanner(text) {
+  const t = text.trim();
+  if (!t) return false;
+  if (BANNER_FULL_RE.test(t) || isRegionMarker(t)) return true;
+  return BANNER_RUN_RE.test(t) && !DIAGRAM_ARROW_RE.test(t);
+}
+function looksLikeCode(text) {
+  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);
+}
+function hasPseudocode(text) {
+  return PSEUDOCODE_RE.test(text);
+}
+function isEnumeratedProseItem(text) {
+  const t = text.trim();
+  return ENUMERATED_ITEM_RE.test(t) && t.split(/\s+/).length >= ENUMERATED_ITEM_MIN_WORDS;
+}
+function isProse(text) {
+  const t = text.trim();
+  if (!t) return false;
+  if (t.endsWith(":")) return true;
+  if (/[.!?]$/.test(t) && /\s/.test(t) && /[a-z]/.test(t) && !looksLikeCode(t) && t.split(/\s+/).length >= 3) {
+    return true;
+  }
+  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;
-function isRedundantNarration(body, statementBelow, standalone) {
+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;
+    if (HELPER_OPENER_RE.test(t) || LETS_RE.test(t)) return true;
+    if (!nested && isSectionLabel(t)) return true;
+    if (isolatedEnumeration && ENUMERATION_RE.test(t)) return true;
+  }
+  return restatesStatementHead(t, statementBelow);
+}
+var STATEMENT_CONTAINERS = /* @__PURE__ */ new Set([
+  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
+]);
+function runCitesAReference(comments, index) {
+  for (let i = index; i >= 0; i--) {
+    if (i < index && !areAdjacentLineComments(comments[i], comments[i + 1])) break;
+    if (hasExternalReference(stripCommentMarker(comments[i]?.value ?? ""))) return true;
   }
-  return restatesNextLine(t, statementBelow);
+  for (let i = index + 1; i < comments.length; i++) {
+    if (!areAdjacentLineComments(comments[i - 1], comments[i])) break;
+    if (hasExternalReference(stripCommentMarker(comments[i]?.value ?? ""))) return true;
+  }
+  return false;
 }
 function areAdjacentLineComments(a, b) {
   return a !== void 0 && b !== void 0 && a.type === "Line" && b.type === "Line" && b.loc.start.line === a.loc.end.line + 1;
@@ -468,7 +636,7 @@ function hasCommentedOutCode(texts, precedingProse) {
   }
   return false;
 }
-var no_comment_cruft_default = import_utils3.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",
@@ -527,6 +695,9 @@ var no_comment_cruft_default = import_utils3.ESLintUtils.RuleCreator(
       Program() {
         const comments = sourceCode.getAllComments();
         const firstCodeLine = sourceCode.ast.tokens[0]?.loc.start.line ?? Number.MAX_SAFE_INTEGER;
+        const enumerated = comments.filter(
+          (c) => c.type === "Line" && ENUMERATION_RE.test(stripCommentMarker(c.value))
+        );
         for (let i = 0; i < comments.length; i++) {
           const comment = comments[i];
           if (comment === void 0) continue;
@@ -547,7 +718,9 @@ var no_comment_cruft_default = import_utils3.ESLintUtils.RuleCreator(
             const body = texts[0];
             const statement = restatableStatementBelow(comment, sourceCode);
             const standalone = !isInsideCommentRun(comments, i);
-            if (body !== void 0 && isRedundantNarration(body, statement, standalone)) {
+            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" });
             }
           }
@@ -559,7 +732,7 @@ var no_comment_cruft_default = import_utils3.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-enum.ts
-var import_utils4 = require("@typescript-eslint/utils");
+var import_utils5 = require("@typescript-eslint/utils");
 var DEFAULT_IGNORE_PATTERNS = [
   /[\\/]generated[\\/]/,
   /[\\/]openapi-gen[\\/]/,
@@ -579,7 +752,7 @@ function hasGeneratedMarker(sourceText) {
   const head = sourceText.slice(0, 1024);
   return /@generated\b/.test(head);
 }
-var no_enum_default = import_utils4.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",
@@ -630,7 +803,7 @@ var no_enum_default = import_utils4.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-insecure-random-id.ts
-var import_utils5 = 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]/;
@@ -771,7 +944,7 @@ function isConcatenatedIntoPathOrDomId(node) {
   collectStaticStringParts(top, parts);
   return parts.some((part) => PATH_OR_DOM_MARKER.test(part));
 }
-var no_insecure_random_id_default = import_utils5.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",
@@ -815,7 +988,7 @@ var no_insecure_random_id_default = import_utils5.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-json-stringify-error.ts
-var import_utils6 = 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"]);
@@ -949,7 +1122,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_utils6.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",
@@ -999,10 +1172,10 @@ var no_json_stringify_error_default = import_utils6.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-log-only-catch.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils9 = require("@typescript-eslint/utils");
 
 // src/rules/_logging.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils8 = require("@typescript-eslint/utils");
 var LOG_METHODS = /* @__PURE__ */ new Set([
   "debug",
   "info",
@@ -1109,7 +1282,7 @@ var DEFAULT_IGNORE_PATTERNS2 = [
   /\.spec\./,
   /[\\/]__tests__[\\/]/
 ];
-var no_log_only_catch_default = import_utils8.ESLintUtils.RuleCreator(
+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",
@@ -1172,7 +1345,7 @@ var no_log_only_catch_default = import_utils8.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-env.ts
-var import_utils9 = 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?$/;
 function isValidatedEnvBoundary(filename, sourceText) {
@@ -1210,7 +1383,7 @@ function isWholeEnvSpread(node) {
   const parent = node.parent;
   return parent.type === "SpreadElement" && parent.argument === node;
 }
-var no_raw_env_default = import_utils9.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",
@@ -1244,12 +1417,12 @@ var no_raw_env_default = import_utils9.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils11 = require("@typescript-eslint/utils");
 function sentinelKind(arg) {
   if (arg === null) {
     return null;
   }
-  if (arg.type === import_utils10.AST_NODE_TYPES.Literal) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.Literal) {
     if (arg.value === null) {
       return "nullish";
     }
@@ -1261,13 +1434,13 @@ function sentinelKind(arg) {
     }
     return null;
   }
-  if (arg.type === import_utils10.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_utils10.AST_NODE_TYPES.ArrayExpression) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
     return "array";
   }
-  if (arg.type === import_utils10.AST_NODE_TYPES.ObjectExpression) {
+  if (arg.type === import_utils11.AST_NODE_TYPES.ObjectExpression) {
     return "object";
   }
   return null;
@@ -1276,25 +1449,25 @@ function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
   }
-  if (arg.type === import_utils10.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_utils10.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_utils10.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_utils10.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_utils10.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_utils10.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.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";
@@ -1334,24 +1507,24 @@ function walkWithinScope(node, visit) {
 function containsThrow(node) {
   return walkWithinScope(
     node,
-    (current) => current.type === import_utils10.AST_NODE_TYPES.ThrowStatement
+    (current) => current.type === import_utils11.AST_NODE_TYPES.ThrowStatement
   );
 }
 function bindsName(param, name) {
   switch (param.type) {
-    case import_utils10.AST_NODE_TYPES.Identifier:
+    case import_utils11.AST_NODE_TYPES.Identifier:
       return param.name === name;
-    case import_utils10.AST_NODE_TYPES.AssignmentPattern:
+    case import_utils11.AST_NODE_TYPES.AssignmentPattern:
       return bindsName(param.left, name);
-    case import_utils10.AST_NODE_TYPES.RestElement:
+    case import_utils11.AST_NODE_TYPES.RestElement:
       return bindsName(param.argument, name);
-    case import_utils10.AST_NODE_TYPES.ArrayPattern:
+    case import_utils11.AST_NODE_TYPES.ArrayPattern:
       return param.elements.some(
         (element) => element !== null && bindsName(element, name)
       );
-    case import_utils10.AST_NODE_TYPES.ObjectPattern:
+    case import_utils11.AST_NODE_TYPES.ObjectPattern:
       return param.properties.some(
-        (property) => property.type === import_utils10.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;
@@ -1366,7 +1539,7 @@ function subtreeReadsName(node, name) {
     if (found) {
       return;
     }
-    if (current.type === import_utils10.AST_NODE_TYPES.Identifier && current.name === name) {
+    if (current.type === import_utils11.AST_NODE_TYPES.Identifier && current.name === name) {
       found = true;
       return;
     }
@@ -1377,10 +1550,10 @@ function subtreeReadsName(node, name) {
       if (key === "parent") {
         continue;
       }
-      if (key === "key" && current.type === import_utils10.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_utils10.AST_NODE_TYPES.MemberExpression && !current.computed) {
+      if (key === "property" && current.type === import_utils11.AST_NODE_TYPES.MemberExpression && !current.computed) {
         continue;
       }
       const value = current[key];
@@ -1413,10 +1586,10 @@ var SAFE_PARSE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "URLPattern"
 ]);
 function isParseShapedNode(node) {
-  if (node.type === import_utils10.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils10.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils10.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_utils10.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils10.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;
@@ -1427,10 +1600,10 @@ var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "arrayBuffer"
 ]);
 function isBodyDecodeNode(node) {
-  return node.type === import_utils10.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils10.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils10.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_utils10.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;
@@ -1448,11 +1621,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_utils10.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_utils10.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils10.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;
@@ -1473,10 +1646,10 @@ function isDeclaredBooleanPredicate(catchNode, kind) {
     return false;
   }
   let declared = enclosingReturnTypeNode(catchNode);
-  if (declared?.type === import_utils10.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils10.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_utils10.AST_NODE_TYPES.TSBooleanKeyword;
+  return declared?.type === import_utils11.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function tryReturnsSafeParse(catchNode) {
   const tryBlock = tryBlockOf(catchNode);
@@ -1492,7 +1665,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_utils10.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;
@@ -1505,7 +1678,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
     return false;
   }
   return walkWithinScope(functionBody, (current) => {
-    if (current.type !== import_utils10.AST_NODE_TYPES.ReturnStatement) {
+    if (current.type !== import_utils11.AST_NODE_TYPES.ReturnStatement) {
       return false;
     }
     if (isWithin(current, catchNode.body)) {
@@ -1524,13 +1697,13 @@ function returnedSentinelKinds(arg) {
     kinds.add(direct);
     return kinds;
   }
-  if (arg.type === import_utils10.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_utils10.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);
     }
@@ -1547,7 +1720,7 @@ function isWithin(node, ancestor) {
   }
   return false;
 }
-var no_sentinel_return_on_catch_default = import_utils10.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",
@@ -1575,7 +1748,7 @@ var no_sentinel_return_on_catch_default = import_utils10.ESLintUtils.RuleCreator
     const matcher = createLogMatcher(loggingOptions);
     function logsOrReportsError(catchBody, caughtName) {
       return walkWithinScope(catchBody, (current) => {
-        if (current.type !== import_utils10.AST_NODE_TYPES.CallExpression) {
+        if (current.type !== import_utils11.AST_NODE_TYPES.CallExpression) {
           return false;
         }
         if (matcher.isLoggingCall(current)) {
@@ -1592,7 +1765,7 @@ var no_sentinel_return_on_catch_default = import_utils10.ESLintUtils.RuleCreator
           return;
         }
         const last = body[body.length - 1];
-        if (last === void 0 || last.type !== import_utils10.AST_NODE_TYPES.ReturnStatement) {
+        if (last === void 0 || last.type !== import_utils11.AST_NODE_TYPES.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -1601,7 +1774,7 @@ var no_sentinel_return_on_catch_default = import_utils10.ESLintUtils.RuleCreator
         if (containsThrow(node.body)) {
           return;
         }
-        const caughtName = node.param?.type === import_utils10.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;
         }
@@ -1628,7 +1801,7 @@ var no_sentinel_return_on_catch_default = import_utils10.ESLintUtils.RuleCreator
 });
 
 // src/rules/no-sequential-await.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 var ARRAY_ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map", "filter"]);
 var SEQUENTIAL_ITERABLE_HINT = /sort|reverse|ordered|sequence|hook|middleware|pipeline|preset|plugin|extension|\bstage|\bstep|\bphase|migration|chain|buffer|stream|teleport|chunk|\bqueue|drain/i;
 var BENCH_FILE_RE = /(^|[\\/])bench(marks?)?[\\/]|\.bench\.[cm]?[jt]sx?$/i;
@@ -1782,7 +1955,7 @@ function shouldReport(awaits, earlyExit, iterableText, asserts = false) {
     (node) => !isTimerYield(node) && !isThreadedAccumulator(node) && !isQueueDrain(node)
   );
 }
-var no_sequential_await_default = import_utils11.ESLintUtils.RuleCreator(
+var no_sequential_await_default = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sequential-await",
@@ -1877,7 +2050,7 @@ var no_sequential_await_default = import_utils11.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-string-concat-in-loop.ts
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -1962,7 +2135,7 @@ function enclosingLoop(node) {
   }
   return null;
 }
-var no_string_concat_in_loop_default = import_utils12.ESLintUtils.RuleCreator(
+var no_string_concat_in_loop_default = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-string-concat-in-loop",
@@ -2025,7 +2198,7 @@ var no_string_concat_in_loop_default = import_utils12.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils13 = require("@typescript-eslint/utils");
+var import_utils14 = 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?$/;
@@ -2051,13 +2224,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_utils13.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils14.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils13.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils14.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils13.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -2072,16 +2245,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils13.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils13.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils14.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils14.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_utils13.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils14.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils13.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils14.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -2098,7 +2271,7 @@ var isGlobalReference = (node, context) => {
   }
   return true;
 };
-var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
+var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unnecessary-use-client",
@@ -2123,13 +2296,13 @@ var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils13.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils14.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils13.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils14.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -2139,7 +2312,7 @@ var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils13.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils14.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -2152,7 +2325,7 @@ var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils13.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils14.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -2219,8 +2392,8 @@ var no_unnecessary_use_client_default = import_utils13.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",
@@ -2230,27 +2403,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils15.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils15.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils15.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils16.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils15.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils16.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_utils15.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -2266,7 +2439,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   }
   return hasStatusBoolean && optionalCount >= MIN_OPTIONAL_MEMBERS && optionalPayloadCount >= 1;
 }
-var prefer_discriminated_union_default = import_utils14.ESLintUtils.RuleCreator(
+var prefer_discriminated_union_default = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-discriminated-union",
@@ -2294,7 +2467,7 @@ var prefer_discriminated_union_default = import_utils14.ESLintUtils.RuleCreator(
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils15.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils16.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -2307,13 +2480,13 @@ var prefer_discriminated_union_default = import_utils14.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils16 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var unwrap = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    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) {
+    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) {
       current = current.expression;
-    } else if (current.type === import_utils16.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils17.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -2324,25 +2497,25 @@ var unwrap = (node) => {
 var isRawPayloadSource = (node) => {
   let current = unwrap(node);
   if (current === null) return false;
-  if (current.type === import_utils16.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils17.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap(current.argument);
   }
-  if (current === null || current.type !== import_utils16.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils17.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap(current.callee);
-  if (callee === null || callee.type !== import_utils16.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap(callee.property);
-  if (property === null || property.type !== import_utils16.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils17.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
     return true;
   }
   const object = unwrap(callee.object);
-  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.
+  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.
   !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
@@ -2350,9 +2523,9 @@ var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils16.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils17.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap(current.callee);
-      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;
+      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;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -2374,15 +2547,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE2 = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils16.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils17.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils16.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils17.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils16.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils17.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils16.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE2.test(callee.name)) {
+    if (callee.type === import_utils17.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE2.test(callee.name)) {
       return true;
     }
   }
@@ -2403,17 +2576,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils16.AST_NODE_TYPES.UnaryExpression:
-      case import_utils16.AST_NODE_TYPES.LogicalExpression:
-      case import_utils16.AST_NODE_TYPES.ChainExpression:
+      case import_utils17.AST_NODE_TYPES.UnaryExpression:
+      case import_utils17.AST_NODE_TYPES.LogicalExpression:
+      case import_utils17.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      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:
+      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:
         return parent.test === current;
       default:
         return false;
@@ -2423,13 +2596,13 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
-  if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils17.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_utils16.ESLintUtils.RuleCreator(
+var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-schema-for-api-payload",
@@ -2460,11 +2633,11 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             context.report({ node: node.id, messageId: "unparsedJsonAccess" });
             return;
@@ -2476,7 +2649,7 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils16.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils17.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -2486,7 +2659,7 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
           }
           return;
         }
-        if (node.left.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -2503,15 +2676,15 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils16.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils17.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_utils16.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils17.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils17.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -2524,13 +2697,13 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
         const obj = unwrap(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          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")) {
+          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")) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils16.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils17.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -2543,7 +2716,7 @@ var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreat
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -2617,8 +2790,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  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) {
+  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) {
     return name.property.name;
   }
   return null;
@@ -2629,7 +2802,7 @@ function isSvgLikeElementName(name) {
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils17.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils18.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -2640,7 +2813,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    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") {
+    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") {
       return true;
     }
     current = current.parent;
@@ -2676,11 +2849,11 @@ var hasSemanticTokenSystem = (filename) => {
   return false;
 };
 var propName = (key) => {
-  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;
+  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;
   return null;
 };
-var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
+var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-semantic-colors",
@@ -2723,27 +2896,27 @@ var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils17.AST_NODE_TYPES.Literal:
+        case import_utils18.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils17.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils18.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils17.AST_NODE_TYPES.ArrayExpression:
+        case import_utils18.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils17.AST_NODE_TYPES.ObjectExpression:
+        case import_utils18.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils17.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils18.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils17.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils18.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils17.AST_NODE_TYPES.LogicalExpression:
+        case import_utils18.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -2751,29 +2924,29 @@ var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils17.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
+      if (node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_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_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) {
+        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) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -2785,7 +2958,7 @@ var prefer_semantic_colors_default = import_utils17.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_utils17.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils18.AST_NODE_TYPES.Literal) return;
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
           return;
         }
@@ -2802,7 +2975,7 @@ var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils19 = 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\/)/;
@@ -2882,7 +3055,7 @@ function getPropertyNode(objNode, propName2) {
   }
   return null;
 }
-var prefer_server_actions_default = import_utils18.ESLintUtils.RuleCreator(
+var prefer_server_actions_default = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-server-actions",
@@ -2957,7 +3130,7 @@ var prefer_server_actions_default = import_utils18.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-shadcn.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 var REPLACEMENTS = {
   select: "Select",
   textarea: "Textarea",
@@ -2972,10 +3145,10 @@ var SKIPPED_INPUT_TYPES = /* @__PURE__ */ new Set(["file", "hidden"]);
 var kebabCase = (component) => component.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 var literalTypeAttr = (node) => {
   for (const attribute of node.attributes) {
-    if (attribute.type !== import_utils19.AST_NODE_TYPES.JSXAttribute || attribute.name.type !== import_utils19.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== "type") {
+    if (attribute.type !== import_utils20.AST_NODE_TYPES.JSXAttribute || attribute.name.type !== import_utils20.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== "type") {
       continue;
     }
-    if (attribute.value?.type === import_utils19.AST_NODE_TYPES.Literal && typeof attribute.value.value === "string") {
+    if (attribute.value?.type === import_utils20.AST_NODE_TYPES.Literal && typeof attribute.value.value === "string") {
       return { kind: "literal", value: attribute.value.value.toLowerCase() };
     }
     return { kind: "dynamic" };
@@ -2983,7 +3156,7 @@ var literalTypeAttr = (node) => {
   return null;
 };
 var hasFileAcceptAttr = (node) => node.attributes.some(
-  (attribute) => attribute.type === import_utils19.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils19.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "accept"
+  (attribute) => attribute.type === import_utils20.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils20.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "accept"
 );
 var resolveInputReplacement = (node) => {
   const typeAttr = literalTypeAttr(node);
@@ -2992,7 +3165,7 @@ var resolveInputReplacement = (node) => {
   if (SKIPPED_INPUT_TYPES.has(typeAttr.value)) return null;
   return INPUT_TYPE_REPLACEMENTS[typeAttr.value] ?? "Input";
 };
-var prefer_shadcn_default = import_utils19.ESLintUtils.RuleCreator(
+var prefer_shadcn_default = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-shadcn",
@@ -3036,36 +3209,36 @@ var prefer_shadcn_default = import_utils19.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-assert-never.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === import_utils20.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils21.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_utils21.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils21.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_utils21.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils21.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.ReturnStatement) {
+  if (statement.type === import_utils21.AST_NODE_TYPES.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils21.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_utils21.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils21.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -3081,12 +3254,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_utils21.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_utils21.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-assert-never",
@@ -3124,7 +3297,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_utils22 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -3135,14 +3308,14 @@ var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils21.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils22.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_utils22.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils22.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -3150,25 +3323,25 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils22.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_utils22.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_utils22.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_utils22.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils22.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_utils22.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils22.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_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-zod-form-validation",
@@ -3188,14 +3361,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_utils22.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_utils22.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -3206,8 +3379,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_utils22.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils22.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -3222,11 +3395,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_utils22.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_utils22.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils22.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -3254,7 +3427,7 @@ 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_utils23 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -3278,15 +3451,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_utils23.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_utils23.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils22.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils23.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils22.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils23.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -3294,7 +3467,7 @@ var calleeChainStartsWithZ = (node) => {
   }
   return false;
 };
-var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
+var zod_naming_convention_default = import_utils23.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "zod-naming-convention",
@@ -3333,13 +3506,13 @@ var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
       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_utils23.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils23.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_utils23.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -3352,7 +3525,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_utils24 = 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"]);
@@ -3494,7 +3667,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_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-cors-wildcard-with-credentials",
@@ -3562,9 +3735,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_utils25 = 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_utils25.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils25.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils25.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -3579,21 +3752,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_utils25.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils25.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils25.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_utils25.AST_NODE_TYPES.Literal:
       return !("regex" in node);
-    case import_utils24.AST_NODE_TYPES.Identifier:
+    case import_utils25.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_utils25.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils25.AST_NODE_TYPES.Literal;
+    case import_utils25.AST_NODE_TYPES.ObjectExpression:
       return node.properties.length === 0;
-    case import_utils24.AST_NODE_TYPES.ArrayExpression:
+    case import_utils25.AST_NODE_TYPES.ArrayExpression:
       return node.elements.length === 0;
-    case import_utils24.AST_NODE_TYPES.TSAsExpression:
+    case import_utils25.AST_NODE_TYPES.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
@@ -3601,7 +3774,7 @@ function isSilentExpression(node) {
 }
 function isSilentHandler(handler) {
   const body = handler.body;
-  if (body.type !== import_utils24.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils25.AST_NODE_TYPES.BlockStatement) {
     return isSilentExpression(body);
   }
   if (body.body.length === 0) {
@@ -3609,13 +3782,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_utils25.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_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-silent-promise-catch",
@@ -3640,7 +3813,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_utils25.AST_NODE_TYPES.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -3652,7 +3825,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_utils25.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils25.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
           return;
         }
         if (isBodyParseCall(node.callee.object)) {
@@ -3661,14 +3834,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_utils25.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_utils25.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils25.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -3683,7 +3856,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_utils26 = require("@typescript-eslint/utils");
 var CODEMOD_FIXTURE_RE = /[\\/]__testfixtures__[\\/]/;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
   "globalThis",
@@ -3700,14 +3873,14 @@ function matchesAnyPattern2(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils25.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils26.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_utils26.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_utils26.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils26.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -3717,9 +3890,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_utils26.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils26.AST_NODE_TYPES.TemplateLiteral;
 }
-var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
+var require_fetch_timeout_default = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-fetch-timeout",
@@ -3756,14 +3929,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_utils26.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_utils26.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_utils26.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils26.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils26.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -3783,23 +3956,23 @@ var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-schema-validate-search.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var VALIDATOR_METHODS = /* @__PURE__ */ new Set([
   "parse",
   "safeParse",
   "decode"
 ]);
 function isConstTypeAnnotation(typeAnnotation) {
-  return typeAnnotation.type === import_utils26.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils26.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
+  return typeAnnotation.type === import_utils27.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils27.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
 }
 function isValidatorCall(node) {
-  return node.callee.type === import_utils26.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils26.AST_NODE_TYPES.Identifier && VALIDATOR_METHODS.has(node.callee.property.name);
+  return node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils27.AST_NODE_TYPES.Identifier && VALIDATOR_METHODS.has(node.callee.property.name);
 }
 function findCastExpression(node, insideValidatorArg) {
-  if ((node.type === import_utils26.AST_NODE_TYPES.TSAsExpression || node.type === import_utils26.AST_NODE_TYPES.TSTypeAssertion) && !isConstTypeAnnotation(node.typeAnnotation) && !insideValidatorArg) {
+  if ((node.type === import_utils27.AST_NODE_TYPES.TSAsExpression || node.type === import_utils27.AST_NODE_TYPES.TSTypeAssertion) && !isConstTypeAnnotation(node.typeAnnotation) && !insideValidatorArg) {
     return node;
   }
-  if (node.type === import_utils26.AST_NODE_TYPES.CallExpression && isValidatorCall(node)) {
+  if (node.type === import_utils27.AST_NODE_TYPES.CallExpression && isValidatorCall(node)) {
     const inCallee = findCastExpression(node.callee, insideValidatorArg);
     if (inCallee !== null) {
       return inCallee;
@@ -3832,7 +4005,7 @@ function findCastExpression(node, insideValidatorArg) {
   }
   return null;
 }
-var require_schema_validate_search_default = import_utils26.ESLintUtils.RuleCreator(
+var require_schema_validate_search_default = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-schema-validate-search",
@@ -3853,11 +4026,11 @@ var require_schema_validate_search_default = import_utils26.ESLintUtils.RuleCrea
     }
     return {
       Property(node) {
-        const isValidateSearchKey = !node.computed && node.key.type === import_utils26.AST_NODE_TYPES.Identifier && node.key.name === "validateSearch" || node.key.type === import_utils26.AST_NODE_TYPES.Literal && node.key.value === "validateSearch";
+        const isValidateSearchKey = !node.computed && node.key.type === import_utils27.AST_NODE_TYPES.Identifier && node.key.name === "validateSearch" || node.key.type === import_utils27.AST_NODE_TYPES.Literal && node.key.value === "validateSearch";
         if (!isValidateSearchKey) {
           return;
         }
-        if (node.value.type !== import_utils26.AST_NODE_TYPES.ArrowFunctionExpression && node.value.type !== import_utils26.AST_NODE_TYPES.FunctionExpression) {
+        if (node.value.type !== import_utils27.AST_NODE_TYPES.ArrowFunctionExpression && node.value.type !== import_utils27.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const cast = findCastExpression(node.value.body, false);
@@ -3870,12 +4043,12 @@ var require_schema_validate_search_default = import_utils26.ESLintUtils.RuleCrea
 });
 
 // src/rules/no-fat-try-blocks.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils27.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils27.AST_NODE_TYPES.FunctionExpression,
-  import_utils27.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils28.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils28.AST_NODE_TYPES.FunctionExpression,
+  import_utils28.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -3973,20 +4146,20 @@ function isNode4(value) {
 }
 function isPureCall(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils27.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type !== import_utils28.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== import_utils27.AST_NODE_TYPES.Identifier) {
+  if (property.type !== import_utils28.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  if (callee.object.type === import_utils27.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === import_utils28.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_utils27.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === import_utils28.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
 function subtreeMatches(stmt, predicate) {
   let found = false;
@@ -4023,20 +4196,20 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils27.AST_NODE_TYPES.AwaitExpression);
+var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils28.AST_NODE_TYPES.AwaitExpression);
 var hasThrowingCallOrNew = (node) => subtreeMatches(
   node,
-  (n) => n.type === import_utils27.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils27.AST_NODE_TYPES.NewExpression && !isPureNew(n)
+  (n) => n.type === import_utils28.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils28.AST_NODE_TYPES.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === import_utils27.AST_NODE_TYPES.ChainExpression || current.type === import_utils27.AST_NODE_TYPES.TSNonNullExpression) {
+  while (current.type === import_utils28.AST_NODE_TYPES.ChainExpression || current.type === import_utils28.AST_NODE_TYPES.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
 }
 function isBareCallStatement(stmt) {
-  return stmt.type === import_utils27.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils27.AST_NODE_TYPES.CallExpression;
+  return stmt.type === import_utils28.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils28.AST_NODE_TYPES.CallExpression;
 }
 function canThrow(stmt) {
   if (hasAwait(stmt)) {
@@ -4045,10 +4218,10 @@ function canThrow(stmt) {
   if (isBareCallStatement(stmt)) {
     return false;
   }
-  if (stmt.type === import_utils27.AST_NODE_TYPES.BlockStatement) {
+  if (stmt.type === import_utils28.AST_NODE_TYPES.BlockStatement) {
     return stmt.body.some(canThrow);
   }
-  if (stmt.type === import_utils27.AST_NODE_TYPES.IfStatement) {
+  if (stmt.type === import_utils28.AST_NODE_TYPES.IfStatement) {
     return hasThrowingCallOrNew(stmt.test) || canThrow(stmt.consequent) || stmt.alternate !== null && canThrow(stmt.alternate);
   }
   return hasThrowingCallOrNew(stmt);
@@ -4059,9 +4232,9 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === import_utils27.AST_NODE_TYPES.ThrowStatement;
+  return last !== void 0 && last.type === import_utils28.AST_NODE_TYPES.ThrowStatement;
 }
-var no_fat_try_blocks_default = import_utils27.ESLintUtils.RuleCreator(
+var no_fat_try_blocks_default = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-fat-try-blocks",
@@ -4105,7 +4278,7 @@ var no_fat_try_blocks_default = import_utils27.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 
 // src/rules/_secret_names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -4367,7 +4540,7 @@ function propertyKeyName2(prop) {
   }
   return null;
 }
-var no_secret_in_log_default = import_utils28.ESLintUtils.RuleCreator(
+var no_secret_in_log_default = import_utils29.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-secret-in-log",
@@ -4444,15 +4617,15 @@ var no_secret_in_log_default = import_utils28.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unsafe-cast.ts
-var import_utils29 = require("@typescript-eslint/utils");
 var import_utils30 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 function isAnyAnnotation(node) {
-  return node.type === import_utils30.AST_NODE_TYPES.TSAnyKeyword;
+  return node.type === import_utils31.AST_NODE_TYPES.TSAnyKeyword;
 }
 function isConstAssertion(typeAnnotation) {
-  return typeAnnotation.type === import_utils30.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils30.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
+  return typeAnnotation.type === import_utils31.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils31.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
 }
-var no_unsafe_cast_default = import_utils29.ESLintUtils.RuleCreator(
+var no_unsafe_cast_default = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unsafe-cast",
@@ -4481,7 +4654,7 @@ var no_unsafe_cast_default = import_utils29.ESLintUtils.RuleCreator(
         return;
       }
       const inner = node.expression;
-      if (inner.type === import_utils30.AST_NODE_TYPES.TSAsExpression || inner.type === import_utils30.AST_NODE_TYPES.TSTypeAssertion) {
+      if (inner.type === import_utils31.AST_NODE_TYPES.TSAsExpression || inner.type === import_utils31.AST_NODE_TYPES.TSTypeAssertion) {
         context.report({ node, messageId: "doubleCast" });
       }
     }
@@ -4493,7 +4666,7 @@ var no_unsafe_cast_default = import_utils29.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils31 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -4536,19 +4709,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils31.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils32.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils31.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils32.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils31.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils31.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils32.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils32.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils31.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils32.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -4577,12 +4750,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils31.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils32.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils31.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils32.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -4590,12 +4763,12 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils31.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils32.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
 }
-var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator(
+var prefer_string_literal_union_default = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-string-literal-union",
@@ -4633,7 +4806,7 @@ var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator
     );
     let services;
     try {
-      services = import_utils31.ESLintUtils.getParserServices(context);
+      services = import_utils32.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -4745,7 +4918,7 @@ var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils31.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils32.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -4833,10 +5006,10 @@ var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils31.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils32.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils31.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils32.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -4845,7 +5018,7 @@ var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator
 });
 
 // src/rules/single-public-export.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 var JUNK_DRAWER_STEMS = /* @__PURE__ */ new Set([
   "util",
   "utils",
@@ -4879,12 +5052,12 @@ var kebabCase2 = (name) => {
   }
   return normalized.replace(CAMEL_BOUNDARY_RE, "-").toLowerCase();
 };
-var isFunctionExpression = (node) => node !== null && (node.type === import_utils32.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils32.AST_NODE_TYPES.FunctionExpression);
+var isFunctionExpression = (node) => node !== null && (node.type === import_utils33.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils33.AST_NODE_TYPES.FunctionExpression);
 var functionConstName = (decl) => {
   if (decl.declarations.length !== 1) return null;
   const [declarator] = decl.declarations;
   if (declarator === void 0) return null;
-  if (declarator.id.type !== import_utils32.AST_NODE_TYPES.Identifier) return null;
+  if (declarator.id.type !== import_utils33.AST_NODE_TYPES.Identifier) return null;
   if (!isFunctionExpression(declarator.init)) return null;
   return declarator.id.name;
 };
@@ -4898,20 +5071,20 @@ var summarizeExports = (body) => {
   };
   for (const statement of body) {
     switch (statement.type) {
-      case import_utils32.AST_NODE_TYPES.ExportAllDeclaration:
+      case import_utils33.AST_NODE_TYPES.ExportAllDeclaration:
         hasReExport = true;
         break;
-      case import_utils32.AST_NODE_TYPES.ExportDefaultDeclaration: {
+      case import_utils33.AST_NODE_TYPES.ExportDefaultDeclaration: {
         names += 1;
         const decl = statement.declaration;
-        if (decl.type === import_utils32.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
+        if (decl.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
-        } else if (decl.type === import_utils32.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
+        } else if (decl.type === import_utils33.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
         }
         break;
       }
-      case import_utils32.AST_NODE_TYPES.ExportNamedDeclaration: {
+      case import_utils33.AST_NODE_TYPES.ExportNamedDeclaration: {
         if (statement.source !== null) {
           hasReExport = true;
           break;
@@ -4922,15 +5095,15 @@ var summarizeExports = (body) => {
           break;
         }
         switch (decl.type) {
-          case import_utils32.AST_NODE_TYPES.FunctionDeclaration:
+          case import_utils33.AST_NODE_TYPES.FunctionDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils32.AST_NODE_TYPES.ClassDeclaration:
+          case import_utils33.AST_NODE_TYPES.ClassDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils32.AST_NODE_TYPES.VariableDeclaration: {
+          case import_utils33.AST_NODE_TYPES.VariableDeclaration: {
             const fnName = functionConstName(decl);
             if (fnName !== null && decl.declarations.length === 1) {
               addCandidate(fnName, statement);
@@ -4950,7 +5123,7 @@ var summarizeExports = (body) => {
   }
   return { names, hasReExport, candidate };
 };
-var single_public_export_default = import_utils32.ESLintUtils.RuleCreator(
+var single_public_export_default = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "single-public-export",
@@ -4970,8 +5143,8 @@ var single_public_export_default = import_utils32.ESLintUtils.RuleCreator(
     if (base.endsWith(".d.ts")) return {};
     if (TEST_FILE_RE.test(base)) return {};
     if (isTestFile(context.filename)) return {};
-    const stem = stemOf(base);
-    if (!JUNK_DRAWER_STEMS.has(stem.toLowerCase())) return {};
+    const stem2 = stemOf(base);
+    if (!JUNK_DRAWER_STEMS.has(stem2.toLowerCase())) return {};
     return {
       Program(node) {
         const { names, hasReExport, candidate } = summarizeExports(node.body);
@@ -4979,11 +5152,11 @@ var single_public_export_default = import_utils32.ESLintUtils.RuleCreator(
         if (names !== 1 || candidate === null) return;
         if (CONVENTIONAL_BUCKET_EXPORTS.has(candidate.name)) return;
         const expected = kebabCase2(candidate.name);
-        if (stem === expected) return;
+        if (stem2 === expected) return;
         context.report({
           node: candidate.node,
           messageId: "renameJunkDrawer",
-          data: { stem, name: candidate.name, expected }
+          data: { stem: stem2, name: candidate.name, expected }
         });
       }
     };
@@ -4991,10 +5164,10 @@ var single_public_export_default = import_utils32.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-offset-pagination.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 
 // src/rules/_sql.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 function stripSqlNoise(text) {
   const out = [...text];
   const n = text.length;
@@ -5055,13 +5228,13 @@ function stripSqlNoise(text) {
 var SUBSTITUTION_MARKER = "?";
 function sqlTextOf(node) {
   switch (node.type) {
-    case import_utils33.AST_NODE_TYPES.Literal:
+    case import_utils34.AST_NODE_TYPES.Literal:
       return typeof node.value === "string" ? node.value : null;
-    case import_utils33.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils34.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_utils34.AST_NODE_TYPES.TaggedTemplateExpression:
       return sqlTextOf(node.quasi);
-    case import_utils33.AST_NODE_TYPES.BinaryExpression: {
+    case import_utils34.AST_NODE_TYPES.BinaryExpression: {
       if (node.operator !== "+") {
         return null;
       }
@@ -5069,7 +5242,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_utils34.AST_NODE_TYPES.ArrayExpression: {
       const parts = [];
       for (const element of node.elements) {
         if (element === null) {
@@ -5089,7 +5262,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_utils34.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils34.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils34.AST_NODE_TYPES.CallExpression;
 }
 function markConsumed(node, consumed) {
   consumed.add(node);
@@ -5139,7 +5312,7 @@ function createSqlListener(handler) {
 // src/rules/no-offset-pagination.ts
 var OFFSET_PAGINATION = /\bOFFSET\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_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-offset-pagination",
@@ -5168,15 +5341,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_utils36 = 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_utils36.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_utils36.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils36.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params[0];
     return argument === void 0 ? null : tupleReturnType(argument);
   }
@@ -5190,30 +5363,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_utils36.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_utils36.AST_NODE_TYPES.TSNamedTupleMember)) {
     return true;
   }
-  if (elements[0]?.type === import_utils35.AST_NODE_TYPES.TSLiteralType) {
+  if (elements[0]?.type === import_utils36.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_utils36.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_utils36.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_utils36.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils36.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_utils36.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils36.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils36.AST_NODE_TYPES.Property) && parent.key.type === import_utils36.AST_NODE_TYPES.Identifier) {
     return parent.key.name;
   }
   return null;
@@ -5221,7 +5394,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_utils36.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils36.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -5230,18 +5403,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_utils36.AST_NODE_TYPES.Program) {
     child = current;
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils35.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils36.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_utils36.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils36.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_utils36.AST_NODE_TYPES.VariableDeclaration) {
+    if (child.type !== import_utils36.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils36.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return child.id.name;
@@ -5251,19 +5424,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_utils36.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_utils36.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_utils36.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils36.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_utils36.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils36.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -5279,7 +5452,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_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-positional-tuple-return",
@@ -5327,7 +5500,7 @@ 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_utils37 = require("@typescript-eslint/utils");
 var MIN_LENGTH = 40;
 var MIN_OCCURRENCES = 3;
 var MIN_DISTINCT_SCOPES = 2;
@@ -5335,9 +5508,9 @@ 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
+  import_utils37.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils37.AST_NODE_TYPES.FunctionExpression,
+  import_utils37.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -5359,9 +5532,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_utils37.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils37.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils37.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils37.AST_NODE_TYPES.TSImportType || parent.type === import_utils37.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils37.AST_NODE_TYPES.TSLiteralType;
 }
-var no_repeated_string_literal_default = import_utils36.ESLintUtils.RuleCreator(
+var no_repeated_string_literal_default = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-repeated-string-literal",
@@ -5401,7 +5574,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_utils37.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -5438,7 +5611,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_utils38 = 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;
@@ -5478,7 +5651,7 @@ function hasRealSelectStar(sql) {
   }
   return false;
 }
-var no_select_star_default = import_utils37.ESLintUtils.RuleCreator(
+var no_select_star_default = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-select-star",
@@ -5507,7 +5680,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_utils39 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS = /* @__PURE__ */ new Set([
   "it",
@@ -5516,34 +5689,34 @@ var TEST_CALLERS = /* @__PURE__ */ new Set([
   "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
+  import_utils39.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils39.AST_NODE_TYPES.FunctionExpression,
+  import_utils39.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_utils39.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_utils39.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils39.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_utils39.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_utils39.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils39.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const body = executor.body;
-  if (body.type !== import_utils38.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils39.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_utils39.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_utils39.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) {
@@ -5551,7 +5724,7 @@ function nearestEnclosingFunction(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils38.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils39.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -5559,29 +5732,29 @@ function nearestEnclosingFunction(node) {
   return null;
 }
 function testCallerName(callee) {
-  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.MemberExpression) {
     return testCallerName(callee.object);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.CallExpression) {
     return testCallerName(callee.callee);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils39.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_utils39.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_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sleep-in-test-body",
@@ -5623,7 +5796,7 @@ var no_sleep_in_test_body_default = import_utils38.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils40 = 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)(_|$)/;
@@ -5636,36 +5809,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils39.AST_NODE_TYPES.Literal:
+    case import_utils40.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils40.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils39.AST_NODE_TYPES.Identifier:
+    case import_utils40.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.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));
+    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));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils40.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils39.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils40.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils40.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils40.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_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -5676,7 +5849,7 @@ function secretNameOf(node) {
   }
   return operandName(node);
 }
-var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.RuleCreator(
+var prefer_constant_time_secret_compare_default = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-constant-time-secret-compare",
@@ -5719,11 +5892,11 @@ var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.Rul
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils41 = 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_utils40.ESLintUtils.RuleCreator(
+var store_insert_requires_on_conflict_default = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "store-insert-requires-on-conflict",
@@ -5752,17 +5925,17 @@ var store_insert_requires_on_conflict_default = import_utils40.ESLintUtils.RuleC
 });
 
 // src/rules/no-dynamic-sql.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = 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_utils41.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.name);
   }
-  if (expression.type === import_utils41.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils42.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.property.name);
   }
-  if (expression.type === import_utils41.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.Literal) {
     return typeof expression.value === "string";
   }
   return false;
@@ -5773,36 +5946,36 @@ function runtimeInterpolations(template) {
   );
 }
 function concatOperands(node) {
-  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return [...concatOperands(node.left), ...concatOperands(node.right)];
   }
   return [node];
 }
 function runtimeConcatOperands(node) {
-  if (node.type !== import_utils41.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
+  if (node.type !== import_utils42.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
     return [];
   }
   const operands = concatOperands(node);
   const hasStringLiteral = operands.some(
-    (operand) => operand.type === import_utils41.AST_NODE_TYPES.Literal && typeof operand.value === "string"
+    (operand) => operand.type === import_utils42.AST_NODE_TYPES.Literal && typeof operand.value === "string"
   );
   if (!hasStringLiteral) {
     return [];
   }
   return operands.filter(
-    (operand) => operand.type !== import_utils41.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
+    (operand) => operand.type !== import_utils42.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_utils41.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils42.AST_NODE_TYPES.TemplateLiteral) {
     return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(RUNTIME_MARKER);
   }
-  if (node.type === import_utils41.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils42.AST_NODE_TYPES.Literal) {
     return typeof node.value === "string" ? node.value : RUNTIME_MARKER;
   }
-  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return staticStatementText(node.left) + staticStatementText(node.right);
   }
   return RUNTIME_MARKER;
@@ -5812,13 +5985,13 @@ function looksLikeSql(node) {
 }
 function statementMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils41.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils42.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
   return methods.has(name) ? name : null;
 }
-var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
+var no_dynamic_sql_default = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-dynamic-sql",
@@ -5857,7 +6030,7 @@ var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
         if (statement === void 0 || !looksLikeSql(statement)) {
           return;
         }
-        const offenders = statement.type === import_utils41.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
+        const offenders = statement.type === import_utils42.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
         for (const offender of offenders) {
           context.report({
             node: offender,
@@ -5871,7 +6044,7 @@ var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -5935,7 +6108,7 @@ function compile(patterns) {
   }
   return compiled;
 }
-var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreator(
+var no_raw_fetch_outside_clients_default = import_utils43.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-fetch-outside-clients",
@@ -5983,7 +6156,7 @@ var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -6002,7 +6175,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils43.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils43.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 null;
   }
   const name = callee.property.name;
@@ -6014,7 +6187,7 @@ function storageMethodName(node, methods) {
   }
   return name;
 }
-var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCreator(
+var no_storage_in_stateless_modules_default = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-storage-in-stateless-modules",
@@ -6072,7 +6245,7 @@ var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCre
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS2 = [
   /[\\/]generated[\\/]/,
@@ -6090,7 +6263,7 @@ function isZodModule(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap3(node) {
-  if (node.type === import_utils44.AST_NODE_TYPES.TSAsExpression || node.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap3(node.expression);
   }
   return node;
@@ -6098,14 +6271,14 @@ function unwrap3(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils44.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils45.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_utils44.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils45.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -6121,7 +6294,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_utils44.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils45.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -6141,7 +6314,7 @@ function resolvesToImportedEnum(node, services) {
   }
   return (symbol.flags & ENUM_SYMBOL_FLAGS) !== 0;
 }
-var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
+var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-zod-native-enum",
@@ -6168,32 +6341,32 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
     }
     let services;
     try {
-      services = import_utils44.ESLintUtils.getParserServices(context);
+      services = import_utils45.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       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_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap3(arg);
-      if (inner.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils45.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -6213,7 +6386,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils45.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils45.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -6232,7 +6405,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -6249,7 +6422,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS3 = [
@@ -6285,9 +6458,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils45.AST_NODE_TYPES.FunctionExpression,
-  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils46.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils46.AST_NODE_TYPES.FunctionExpression,
+  import_utils46.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile3(filename, sourceText) {
@@ -6300,13 +6473,13 @@ function isTestFile2(filename) {
   return TEST_FILE_PATTERNS.some((re) => re.test(filename));
 }
 function unwrap4(node) {
-  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) {
+  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) {
     return unwrap4(node.expression);
   }
   return node;
 }
 function isRegexLiteral(node) {
-  return node.type === import_utils45.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils46.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6314,29 +6487,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap4(node);
   switch (inner.type) {
-    case import_utils45.AST_NODE_TYPES.Literal: {
+    case import_utils46.AST_NODE_TYPES.Literal: {
       return true;
     }
-    case import_utils45.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils46.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    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.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.ArrayExpression: {
+    case import_utils46.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils45.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils46.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils45.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils46.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils46.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils45.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils46.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6349,7 +6522,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap4(node);
-  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) {
+  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) {
     return unwrap4(inner.arguments[0]);
   }
   return inner;
@@ -6365,19 +6538,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils45.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils46.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils46.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_utils45.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap4(arg);
-    if (entries.type !== import_utils45.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -6406,10 +6579,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils46.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  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) {
+  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) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -6423,43 +6596,43 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    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) {
+    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) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
 }
-var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreator(
+var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-module-level-constant",
@@ -6511,7 +6684,7 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils46.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6523,10 +6696,10 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils45.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils46.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils46.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6552,6 +6725,542 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
   }
 });
 
+// src/rules/jsdoc-restates-signature.ts
+var import_utils47 = require("@typescript-eslint/utils");
+var VALUE_TAGS = /* @__PURE__ */ new Set([
+  "alpha",
+  "author",
+  "beta",
+  "category",
+  "copyright",
+  "default",
+  "defaultvalue",
+  "deprecated",
+  "example",
+  "experimental",
+  "fileoverview",
+  "fixme",
+  "group",
+  "inheritdoc",
+  "internal",
+  "license",
+  "link",
+  "module",
+  "override",
+  "packagedocumentation",
+  "remarks",
+  "see",
+  "since",
+  "template",
+  "throws",
+  "todo",
+  "typeparam"
+]);
+var MODELLED_TAGS = /* @__PURE__ */ new Set([
+  "arg",
+  "argument",
+  "async",
+  "description",
+  "param",
+  "return",
+  "returns"
+]);
+var PARAM_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param"]);
+var RETURN_TAGS = /* @__PURE__ */ new Set(["return", "returns"]);
+var DIRECTIVE_RE2 = /^\s*(?:eslint\b|eslint-|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|@vite|webpack|@jsx|@jest-environment|@vitest-environment|#__)/i;
+var STOPWORDS2 = 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 based
+   function method component hook class instance object value values data item
+   items element callback handler prop props param parameter argument arg return
+   returns returning result optional required default true false null undefined
+   string number boolean array list promise`.split(/\s+/)
+);
+var WORD_RE2 = /[A-Za-z]+/g;
+function parseJsDoc(value) {
+  const lines = value.replace(/^\*/, "").split("\n").map((line) => line.replace(/^\s*\*?\s?/, ""));
+  const description = [];
+  const tags = [];
+  let current = null;
+  for (const line of lines) {
+    const match = /^\s*@(\w[\w-]*)\s*(.*)$/.exec(line);
+    if (match) {
+      current = { name: (match[1] ?? "").toLowerCase(), text: match[2] ?? "" };
+      tags.push(current);
+    } else if (current !== null) {
+      current.text += ` ${line.trim()}`;
+    } else {
+      description.push(line);
+    }
+  }
+  return { description: description.join("\n").trim(), tags };
+}
+function proseTokens(text) {
+  return (text.match(WORD_RE2) ?? []).map((word) => word.toLowerCase()).filter((word) => word.length > 1 && !STOPWORDS2.has(word));
+}
+function covered(text, known) {
+  const stems = /* @__PURE__ */ new Set();
+  for (const token of known) stems.add(stem(token));
+  return proseTokens(text).every((word) => known.has(word) || stems.has(stem(word)));
+}
+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:
+      return node.declaration == null ? null : declarationNames(node.declaration);
+    case import_utils47.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils47.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:
+      return node.id === null ? null : { name: node.id.name, params: [] };
+    case import_utils47.AST_NODE_TYPES.VariableDeclaration: {
+      const declarator = node.declarations[0];
+      if (declarator === void 0 || declarator.id.type !== import_utils47.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) : [];
+      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) : [];
+      return { name: node.key.name, params };
+    }
+    default:
+      return null;
+  }
+}
+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;
+  }
+  return names;
+}
+function tokensOf(names) {
+  const tokens = /* @__PURE__ */ new Set();
+  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(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "jsdoc-restates-signature",
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      description: "Flag a JSDoc block whose description and tags only re-spell the signature they document."
+    },
+    schema: [],
+    messages: {
+      restatesSignature: "JSDoc only re-spells the signature \u2014 delete it, or say what the caller cannot read off the name (what it throws, what it assumes, why it exists).",
+      deleteBlock: "Delete the JSDoc block."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    const sourceCode = context.sourceCode;
+    return {
+      Program() {
+        for (const comment of sourceCode.getAllComments()) {
+          if (comment.type !== "Block" || !comment.value.startsWith("*")) continue;
+          const { description, tags } = parseJsDoc(comment.value);
+          if (DIRECTIVE_RE2.test(description)) continue;
+          const tagNames = new Set(tags.map((tag) => tag.name));
+          if ([...tagNames].some((name) => VALUE_TAGS.has(name))) continue;
+          if ([...tagNames].some((name) => !MODELLED_TAGS.has(name))) continue;
+          if (isProtected(description)) continue;
+          const token = sourceCode.getTokenAfter(comment, { includeComments: false });
+          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) {
+            declaration = declarationNames(node);
+            if (declaration !== null) break;
+            node = node.parent ?? null;
+          }
+          if (declaration === null) continue;
+          const paramTags = tags.filter((tag) => PARAM_TAGS.has(tag.name));
+          const returnTags = tags.filter((tag) => RETURN_TAGS.has(tag.name));
+          if (description.length === 0 && paramTags.length === 0 && returnTags.length === 0) {
+            continue;
+          }
+          const nameTokens = tokensOf([declaration.name]);
+          const paramTokens = tokensOf(declaration.params);
+          const known = /* @__PURE__ */ new Set([...nameTokens, ...paramTokens]);
+          let addsNothing = covered(description, known);
+          for (const tag of paramTags) {
+            const text = tag.text.replace(/^\{[^}]*\}\s*/, "");
+            const match = /^\[?([A-Za-z_$][\w.$]*)\]?\s*-?\s*([\s\S]*)$/.exec(text);
+            if (match === null) {
+              addsNothing = false;
+              break;
+            }
+            const own = /* @__PURE__ */ new Set([...splitIdentifier(match[1]?.split(".").pop() ?? ""), ...nameTokens]);
+            if (!covered(match[2] ?? "", own)) {
+              addsNothing = false;
+              break;
+            }
+            for (const part of splitIdentifier(match[1]?.split(".").pop() ?? "")) known.add(part);
+          }
+          if (addsNothing) {
+            for (const tag of returnTags) {
+              if (!covered(tag.text.replace(/^\{[^}]*\}\s*/, ""), known)) {
+                addsNothing = false;
+                break;
+              }
+            }
+          }
+          if (!addsNothing) continue;
+          context.report({
+            node: comment,
+            messageId: "restatesSignature",
+            suggest: [
+              {
+                messageId: "deleteBlock",
+                fix: (fixer) => fixer.removeRange([comment.range[0], token.range[0]])
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-restated-comment.ts
+var import_utils48 = 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;
+var CODEY_RE = /^[\w.$[\]'"]+\s*[:=]\s*\S|^[\w.$]+\s*\(|^(?:return|throw|await|import|export|const|let|var)\b.*[=()[\]{}]/;
+var BANNERISH_RE = /[=\-─-╿*#~_.]{3,}|^[A-Z0-9 _:-]+$/;
+var MODALITY_RE = /\b(?:can|could|should|shall|may|might|must|will|would|cannot)\b/i;
+var LEAD_IN_RE = /:$/;
+var EMPHASIS_RE = /\*\w[^*]*\*|`[^`]+`/;
+var NEGATION_WORD_RE = /\b(?:no|not|never|neither|nor|without|none|non)\b/i;
+var ACTION_STMT_RE = /[\w.$\])]\s*\(|^\s*(?:return|throw|await|yield)\b/;
+var NON_ASCII_LETTER_RE = /[^\p{ASCII}\p{N}\p{P}\p{Z}]/u;
+function areAdjacentLineComments2(a, b) {
+  return a !== void 0 && b !== void 0 && a.type === "Line" && b.type === "Line" && b.loc.start.line === a.loc.end.line + 1;
+}
+function headsSiblingRun(node) {
+  const parent = node.parent;
+  if (parent === void 0) return false;
+  const body = "body" in parent && Array.isArray(parent.body) ? parent.body : void 0;
+  if (body === void 0) return false;
+  const index = body.indexOf(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(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-restated-comment",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag a single-line comment whose every word already appears on the statement below it."
+    },
+    schema: [],
+    messages: {
+      restatesLineBelow: "Comment restates the statement below it \u2014 delete it, or replace it with the *why*; the code already carries the *what*."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    const sourceCode = context.sourceCode;
+    const lines = sourceCode.lines;
+    function isStandalone(comment) {
+      const before = sourceCode.getTokenBefore(comment, { includeComments: false });
+      return !before || before.loc.end.line < comment.loc.start.line;
+    }
+    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) {
+        if (headsSiblingRun(node)) return true;
+      }
+      return false;
+    }
+    return {
+      Program() {
+        const comments = sourceCode.getAllComments();
+        for (let i = 0; i < comments.length; i++) {
+          const comment = comments[i];
+          if (comment === void 0 || comment.type !== "Line") continue;
+          if (!isStandalone(comment)) continue;
+          if (areAdjacentLineComments2(comments[i - 1], comment) || areAdjacentLineComments2(comment, comments[i + 1])) {
+            continue;
+          }
+          const body = comment.value.replace(/^\/*/, "").trim();
+          if (body.length === 0 || body.endsWith("?")) continue;
+          if (DIRECTIVE_RE3.test(body) || CODEY_RE.test(body) || BANNERISH_RE.test(body)) continue;
+          if (NON_ASCII_LETTER_RE.test(body) || isProtected(body)) continue;
+          if (MODALITY_RE.test(body) || LEAD_IN_RE.test(body) || EMPHASIS_RE.test(body)) continue;
+          if (NEGATION_WORD_RE.test(body)) continue;
+          if (body.split(/\s+/).length > MAX_WORDS) continue;
+          const tokens = contentTokens(body);
+          if (tokens.length < MIN_CONTENT_TOKENS) continue;
+          const statement = restatableStatementBelow(comment, sourceCode);
+          if (statement === null) continue;
+          if (restatesStatementHead(body, statement)) continue;
+          const line = lines[comment.loc.start.line] ?? "";
+          if (!ACTION_STMT_RE.test(line)) continue;
+          if (labelsASiblingRun(comment)) continue;
+          if (restates(tokens, codeTokens(line))) {
+            context.report({ node: comment, messageId: "restatesLineBelow" });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/trailing-value-narration.ts
+var import_utils49 = 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([
+  "bytes",
+  "characters",
+  "chars",
+  "day",
+  "days",
+  "gb",
+  "hour",
+  "hours",
+  "hr",
+  "hrs",
+  "hz",
+  "items",
+  "k",
+  "kb",
+  "khz",
+  "m",
+  "mb",
+  "milliseconds",
+  "min",
+  "mins",
+  "minute",
+  "minutes",
+  "ms",
+  "pct",
+  "percent",
+  "px",
+  "retries",
+  "rows",
+  "s",
+  "sec",
+  "second",
+  "seconds",
+  "secs",
+  "times",
+  "tokens"
+]);
+var STOPWORDS3 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "we",
+  "with"
+]);
+var DIRECTIVE_RE4 = /^\s*(?:eslint\b|eslint-|sarj-noqa\b|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|todo\b|fixme\b|hack\b|xxx\b)/i;
+function numbersIn(text) {
+  return new Set(text.match(NUMBER_RE) ?? []);
+}
+function narratesValue(body, code) {
+  if (body.length === 0 || DIRECTIVE_RE4.test(body) || hasExternalReference(body)) return false;
+  const codeNumbers = numbersIn(code);
+  if (codeNumbers.size === 0) return false;
+  const words = (body.match(WORD_RE3) ?? []).map((word) => word.toLowerCase());
+  if (words.length === 0) return false;
+  const commentNumbers = numbersIn(body);
+  if (commentNumbers.size === 0) return false;
+  for (const number of commentNumbers) {
+    if (!codeNumbers.has(number)) return false;
+  }
+  const identifiers = codeTokens(code);
+  const stems = /* @__PURE__ */ new Set();
+  for (const token of identifiers) stems.add(stem(token));
+  return words.every(
+    (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(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "trailing-value-narration",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag a trailing comment whose every word and number is already on the line it annotates."
+    },
+    schema: [],
+    messages: {
+      narratesValue: "Trailing comment restates the literal on this line \u2014 put the unit in the name (STALE_TIME_MS) so it cannot drift."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    const sourceCode = context.sourceCode;
+    function isTrailing(comment) {
+      const before = sourceCode.getTokenBefore(comment, { includeComments: false });
+      return before !== null && before.loc.end.line === comment.loc.start.line;
+    }
+    return {
+      Program() {
+        for (const comment of sourceCode.getAllComments()) {
+          if (!isTrailing(comment)) continue;
+          const line = sourceCode.lines[comment.loc.start.line - 1] ?? "";
+          const code = line.slice(0, comment.loc.start.column);
+          const body = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
+          if (narratesValue(body, code)) {
+            context.report({ node: comment, messageId: "narratesValue" });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-tautological-expect.ts
+var import_utils50 = require("@typescript-eslint/utils");
+var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
+  "toBeDefined",
+  "toBeUndefined",
+  "toBeNull",
+  "toBeTruthy",
+  "toBeFalsy",
+  "toBeNaN"
+]);
+var OPERAND_PREVIEW_CHARS = 40;
+var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
+function isLiteral(node) {
+  switch (node.type) {
+    case import_utils50.AST_NODE_TYPES.Literal:
+      return true;
+    case import_utils50.AST_NODE_TYPES.TemplateLiteral:
+      return node.expressions.length === 0;
+    case import_utils50.AST_NODE_TYPES.UnaryExpression:
+      return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
+    case import_utils50.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.every((element) => element !== null && isLiteral(element));
+    case import_utils50.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.every(
+        (property) => property.type === import_utils50.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+      );
+    default:
+      return false;
+  }
+}
+function expectOperand(callee) {
+  const receiver = callee.object;
+  if (receiver.type !== import_utils50.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils50.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+    return null;
+  }
+  return receiver.arguments[0] ?? null;
+}
+var no_tautological_expect_default = import_utils50.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-tautological-expect",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow an assertion whose operands are all literals; its outcome is fixed before the code runs, so it can never fail."
+    },
+    schema: [],
+    messages: {
+      tautologicalComparison: "`expect({{operand}}).{{matcher}}({{operand}})` compares a literal with an identical literal \u2014 it passes even if the code under test is deleted. Assert on a value the code produced, or delete the test.",
+      tautologicalMatcher: "`expect({{operand}}).{{matcher}}()` asserts on a literal, so its outcome is fixed before the code runs. Assert on a value the code produced, or delete the test."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isTestFile(context.filename)) {
+      return {};
+    }
+    const preview2 = (node) => {
+      const text = context.sourceCode.getText(node).replaceAll(/\s+/gu, " ");
+      return text.length > OPERAND_PREVIEW_CHARS ? `${text.slice(0, OPERAND_PREVIEW_CHARS)}\u2026` : text;
+    };
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.computed) {
+          return;
+        }
+        if (callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        const matcher = callee.property.name;
+        const operand = expectOperand(callee);
+        if (operand === null || !isLiteral(operand)) {
+          return;
+        }
+        if (ZERO_ARG_MATCHERS.has(matcher) && node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "tautologicalMatcher",
+            data: { operand: preview2(operand), matcher }
+          });
+          return;
+        }
+        const expected = node.arguments[0];
+        if (!EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === void 0 || !isLiteral(expected)) {
+          return;
+        }
+        if (context.sourceCode.getText(operand) !== context.sourceCode.getText(expected)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "tautologicalComparison",
+          data: { operand: preview2(operand), matcher }
+        });
+      }
+    };
+  }
+});
+
 // src/index.ts
 var rules = {
   "enforce-file-structure": enforce_file_structure_default,
@@ -6594,12 +7303,16 @@ var rules = {
   "no-raw-fetch-outside-clients": no_raw_fetch_outside_clients_default,
   "no-storage-in-stateless-modules": no_storage_in_stateless_modules_default,
   "no-zod-native-enum": no_zod_native_enum_default,
-  "prefer-module-level-constant": prefer_module_level_constant_default
+  "prefer-module-level-constant": prefer_module_level_constant_default,
+  "jsdoc-restates-signature": jsdoc_restates_signature_default,
+  "no-restated-comment": no_restated_comment_default,
+  "trailing-value-narration": trailing_value_narration_default,
+  "no-tautological-expect": no_tautological_expect_default
 };
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.12.2"
+    version: "2.14.0"
   },
   rules,
   configs: {
@@ -6655,7 +7368,26 @@ var plugin = {
         // Mined from two years of PR review — the single most frequent uncovered
         // theme (~37 PRs). Measured 17 hits / 1085 real TS files, all true
         // positives, so it is safe to run everywhere.
-        "@sarj/prefer-module-level-constant": "warn"
+        "@sarj/prefer-module-level-constant": "warn",
+        // Anti-comment-verbosity family (2026-07), from a 37,918-comment,
+        // nine-repo measurement study. Each is a deletion-class finding, so each
+        // was validated against pydantic / trio / attrs as well as the maintained
+        // repos: `no-restated-comment` 0 hits in bulbul and 4 in the three famous
+        // corpora combined; `trailing-value-narration` 18 hits, 18 true
+        // positives; `jsdoc-restates-signature` 36 hits, 0 measured false
+        // positives, and it offers a suggestion rather than a `--fix` because a
+        // wrong deletion is silent information loss.
+        "@sarj/no-restated-comment": "warn",
+        "@sarj/jsdoc-restates-signature": "warn",
+        "@sarj/trailing-value-narration": "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`
+        // survived in internal-automations: the file HAS an assertion.
+        // Measured across 5,819 .ts/.tsx files (1,003 of them test files) in
+        // six internal repos plus got / hono / swr / trpc: 3 hits, 3 true
+        // positives, 0 false positives.
+        "@sarj/no-tautological-expect": "warn"
       }
     },
     strict: {
@@ -6718,7 +7450,14 @@ var plugin = {
         "@sarj/no-storage-in-stateless-modules": "error",
         // Mined from two years of PR review (SARJ-928).
         "@sarj/no-zod-native-enum": "error",
-        "@sarj/prefer-module-level-constant": "error"
+        "@sarj/prefer-module-level-constant": "error",
+        // Anti-comment-verbosity family (2026-07) — see the `recommended` block
+        // for the measured hit counts and false-positive rates.
+        "@sarj/no-restated-comment": "error",
+        "@sarj/jsdoc-restates-signature": "error",
+        "@sarj/trailing-value-narration": "error",
+        // TS half of SARJ057 — see the `recommended` block for the measurement.
+        "@sarj/no-tautological-expect": "error"
       }
     }
   }