@sarj/eslint-plugin 2.3.4 → 2.4.1

package/dist/index.cjs

@@ -37,43 +37,20 @@ module.exports = __toCommonJS(index_exports);
 
 // src/rules/enforce-file-structure.ts
 var import_utils = require("@typescript-eslint/utils");
-var SECTION = {
-  declarations: 0,
-  functions: 1,
-  exports: 2
-};
-var SECTION_NAMES = ["declarations", "functions", "exports"];
-var sectionName = (ordinal) => {
-  const name = SECTION_NAMES[ordinal];
-  return name ?? "unknown";
-};
-var SERVER_ACTION_FILE_RE = /(?:^|\/)actions\/|\.action\.[jt]sx?$|(?:^|\/)actions\.[jt]sx?$/;
-var isFunctionExpression = (node) => node.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils.AST_NODE_TYPES.FunctionExpression;
-var isFunctionLikeVariable = (statement) => statement.declarations.length > 0 && statement.declarations.every(
-  (decl) => decl.init !== null && isFunctionExpression(decl.init)
-);
-var getStatementSection = (statement) => {
+var classifyStatement = (statement) => {
   switch (statement.type) {
     case import_utils.AST_NODE_TYPES.ImportDeclaration:
-    case import_utils.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils.AST_NODE_TYPES.TSEnumDeclaration:
-    case import_utils.AST_NODE_TYPES.ClassDeclaration:
-      return SECTION.declarations;
-    case import_utils.AST_NODE_TYPES.VariableDeclaration:
-      return isFunctionLikeVariable(statement) ? SECTION.functions : SECTION.declarations;
-    case import_utils.AST_NODE_TYPES.FunctionDeclaration:
-      return SECTION.functions;
-    case import_utils.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return "import";
     case import_utils.AST_NODE_TYPES.ExportAllDeclaration:
-      return SECTION.exports;
+      return "reexport";
+    case import_utils.AST_NODE_TYPES.ExportNamedDeclaration:
+      return statement.declaration === null ? "reexport" : "body";
     default:
-      return SECTION.functions;
+      return "body";
   }
 };
+var isStringDirective = (statement) => statement.type === import_utils.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils.AST_NODE_TYPES.Literal && typeof statement.expression.value === "string" && statement.expression.value.startsWith("use ");
 var isUseServerDirective = (statement) => {
-  if (statement === void 0) return false;
   if (statement.type !== import_utils.AST_NODE_TYPES.ExpressionStatement) return false;
   const expr = statement.expression;
   if (expr.type !== import_utils.AST_NODE_TYPES.Literal) return false;
@@ -86,47 +63,45 @@ var enforce_file_structure_default = import_utils.ESLintUtils.RuleCreator(
   meta: {
     type: "suggestion",
     docs: {
-      description: "Enforce that function definitions follow the file's top-of-file declarations (imports, types, constants, classes) \u2014 the stepdown rule. Ordering among non-function declarations is not enforced. Server-action files (under `/actions/`, named `*.action.ts`, or `actions.ts`) must also begin with a `use server` directive."
+      description: "Require `import` statements to come first, then allow step-down ordering (public API first, private helpers below) for the rest of the file. Exported statements are classified by WHAT they export \u2014 an exported interface is a declaration, an exported function is a function \u2014 so a public exported function followed by a private helper, or an exported interface among declarations, is allowed. Re-exports (`export { \u2026 } from`, `export *`, `export { \u2026 }`) are a neutral group, so generated namespace barrels pass. When a module contains a `use server` directive, it must be the first statement in the file."
     },
     schema: [],
     messages: {
-      incorrectOrder: "File structure violation: {{current}} should come before {{expected}}",
-      useServerDirective: "Server action files must start with 'use server' directive"
+      importsFirst: "File structure violation: import statements must come before other declarations",
+      useServerDirective: "A 'use server' directive must be the first statement in the file"
     }
   },
   defaultOptions: [],
   create(context) {
-    const filename = context.filename;
-    const isServerAction = SERVER_ACTION_FILE_RE.test(filename);
     return {
       Program(node) {
         const body = node.body;
-        if (isServerAction) {
-          const firstNode = body[0];
-          if (!isUseServerDirective(firstNode)) {
-            context.report({
-              node,
-              messageId: "useServerDirective"
-            });
-          }
+        const misplacedUseServer = body.find(
+          (statement, index) => index > 0 && isUseServerDirective(statement)
+        );
+        if (misplacedUseServer !== void 0) {
+          context.report({
+            node: misplacedUseServer,
+            messageId: "useServerDirective"
+          });
         }
-        let currentSection = SECTION.declarations;
+        let seenBody = false;
         for (const statement of body) {
-          if (statement.type === import_utils.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils.AST_NODE_TYPES.Literal && typeof statement.expression.value === "string" && statement.expression.value.startsWith("use ")) {
-            continue;
-          }
-          const statementSection = getStatementSection(statement);
-          if (statementSection < currentSection) {
-            context.report({
-              node: statement,
-              messageId: "incorrectOrder",
-              data: {
-                current: sectionName(statementSection),
-                expected: sectionName(currentSection)
+          if (isStringDirective(statement)) continue;
+          switch (classifyStatement(statement)) {
+            case "reexport":
+              continue;
+            case "body":
+              seenBody = true;
+              continue;
+            case "import":
+              if (seenBody) {
+                context.report({
+                  node: statement,
+                  messageId: "importsFirst"
+                });
               }
-            });
-          } else if (statementSection > currentSection) {
-            currentSection = statementSection;
+              continue;
           }
         }
       }
@@ -272,7 +247,7 @@ var no_client_side_data_fetching_default = import_utils2.ESLintUtils.RuleCreator
 // src/rules/no-comment-cruft.ts
 var import_utils3 = require("@typescript-eslint/utils");
 var LEADING_PREAMBLE_MIN = 4;
-var DIRECTIVE_RE = /^(eslint\b|eslint-|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\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 BANNER_FULL_RE = /^[\s\-=*#~_+.]{4,}$/;
 var BANNER_RUN_RE = /={4,}|-{4,}|#{4,}|\*{4,}|~{4,}/;
@@ -280,8 +255,9 @@ var REGION_RE = /^#?(?:end)?region\b/i;
 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*\/\//, "").replace(/^\s*\*+/, "").trim();
+  return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
 }
 function isDirective(text) {
   return DIRECTIVE_RE.test(text.trim());
@@ -297,6 +273,30 @@ function looksLikeCode(text) {
   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 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;
+}
+function hasCommentedOutCode(texts, precedingProse) {
+  for (let i = 0; i < texts.length; i++) {
+    const line = texts[i];
+    if (line === void 0 || !looksLikeCode(line) || hasPseudocode(line)) {
+      continue;
+    }
+    const prev = i > 0 ? texts[i - 1] : void 0;
+    if (prev !== void 0 ? isProse(prev) : precedingProse) continue;
+    return true;
+  }
+  return false;
+}
 var no_comment_cruft_default = import_utils3.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -351,12 +351,19 @@ 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;
-        for (const comment of comments) {
+        for (let i = 0; i < comments.length; i++) {
+          const comment = comments[i];
+          if (comment === void 0) continue;
           if (isJsDoc(comment) || !isStandalone(comment)) continue;
+          if (LICENSE_RE.test(comment.value)) continue;
           const texts = comment.value.split("\n").map(stripCommentMarker).filter((l) => l.length > 0 && !isDirective(l));
           if (texts.some(isBanner)) {
             context.report({ node: comment, messageId: "sectionBanner" });
-          } else if (texts.some(looksLikeCode)) {
+            continue;
+          }
+          const prev = comments[i - 1];
+          const precedingProse = prev !== void 0 && prev.type === "Line" && prev.loc.end.line === comment.loc.start.line - 1 && isProse(stripCommentMarker(prev.value));
+          if (hasCommentedOutCode(texts, precedingProse)) {
             context.report({ node: comment, messageId: "commentedOutCode" });
           }
         }
@@ -438,7 +445,9 @@ var no_enum_default = import_utils4.ESLintUtils.RuleCreator(
 
 // src/rules/no-insecure-random-id.ts
 var import_utils5 = require("@typescript-eslint/utils");
-var NAME_PATTERN = /id|token|key|secret|uuid|nonce|session|password|salt/i;
+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]/;
 function isMathRandomCall(node) {
   if (node.type !== "CallExpression") {
     return false;
@@ -450,6 +459,24 @@ function isMathRandomCall(node) {
   const { object, property } = callee;
   return object.type === "Identifier" && object.name === "Math" && property.type === "Identifier" && property.name === "random";
 }
+function climbValueChain(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent) {
+    if (parent.type === "MemberExpression" && parent.object === current && !parent.computed) {
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    if (parent.type === "CallExpression" && parent.callee === current) {
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
 function isPartOfToString36Chain(node) {
   let current = node;
   let parent = current.parent;
@@ -515,6 +542,49 @@ function findEnclosingName(node) {
   }
   return void 0;
 }
+function collectStaticStringParts(node, out) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    out.push(node.value);
+    return;
+  }
+  if (node.type === "TemplateLiteral") {
+    for (const quasi of node.quasis) {
+      out.push(quasi.value.cooked ?? quasi.value.raw);
+    }
+    return;
+  }
+  if (node.type === "BinaryExpression" && node.operator === "+") {
+    collectStaticStringParts(node.left, out);
+    collectStaticStringParts(node.right, out);
+  }
+}
+function isConcatenatedIntoPathOrDomId(node) {
+  const valueNode = climbValueChain(node);
+  let current = valueNode;
+  let parent = current.parent;
+  let top;
+  while (parent) {
+    if (parent.type === "BinaryExpression" && parent.operator === "+" && (parent.left === current || parent.right === current)) {
+      top = parent;
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    if (parent.type === "TemplateLiteral") {
+      top = parent;
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    break;
+  }
+  if (!top) {
+    return false;
+  }
+  const parts = [];
+  collectStaticStringParts(top, parts);
+  return parts.some((part) => PATH_OR_DOM_MARKER.test(part));
+}
 var no_insecure_random_id_default = import_utils5.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -536,12 +606,18 @@ var no_insecure_random_id_default = import_utils5.ESLintUtils.RuleCreator(
         if (!isMathRandomCall(node)) {
           return;
         }
-        if (isPartOfToString36Chain(node)) {
+        const name = findEnclosingName(node);
+        if (name !== void 0 && STRONG_SECURITY_PATTERN.test(name)) {
           context.report({ node, messageId: "insecureRandomId" });
           return;
         }
-        const name = findEnclosingName(node);
-        if (name !== void 0 && NAME_PATTERN.test(name)) {
+        if (name !== void 0 && NON_SECURITY_ID_PATTERN.test(name)) {
+          return;
+        }
+        if (isConcatenatedIntoPathOrDomId(node)) {
+          return;
+        }
+        if (isPartOfToString36Chain(node)) {
           context.report({ node, messageId: "insecureRandomId" });
         }
       }
@@ -552,6 +628,8 @@ 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 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"]);
 function isCatchBinding(scope, name) {
   let current = scope;
   while (current) {
@@ -567,6 +645,98 @@ function isCatchBinding(scope, name) {
   }
   return false;
 }
+function memberSuggestsError(member, scope) {
+  const propName2 = !member.computed && member.property.type === "Identifier" ? member.property.name : null;
+  if (propName2 !== null && ERROR_PROP_PATTERN.test(propName2)) {
+    return true;
+  }
+  const base = member.object;
+  const baseSuggestsError = base.type === "Identifier" && (ERROR_NAME_PATTERN.test(base.name) || isCatchBinding(scope, base.name));
+  if (baseSuggestsError) {
+    return propName2 === null || !SAFE_STRING_PROPS.has(propName2.toLowerCase());
+  }
+  return false;
+}
+function instanceofErrorSubject(test) {
+  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.right.type === "Identifier" && test.right.name === "Error") {
+    return test.left;
+  }
+  return null;
+}
+var TYPE_GUARD_PATTERN = /^(is|has)[A-Z]/;
+function typeGuardSubject(test) {
+  const arg = test.type === "CallExpression" ? test.arguments[0] : void 0;
+  if (test.type === "CallExpression" && test.callee.type === "Identifier" && TYPE_GUARD_PATTERN.test(test.callee.name) && test.arguments.length === 1 && arg !== void 0 && arg.type !== "SpreadElement") {
+    return arg;
+  }
+  return null;
+}
+function positiveErrorSubject(test) {
+  return instanceofErrorSubject(test) ?? typeGuardSubject(test);
+}
+function negatedInstanceofErrorSubject(test) {
+  if (test.type === "UnaryExpression" && test.operator === "!") {
+    return positiveErrorSubject(test.argument);
+  }
+  return null;
+}
+function branchTerminates(branch) {
+  const body = branch.type === "BlockStatement" ? branch.body : [branch];
+  const last = body[body.length - 1];
+  return last !== void 0 && (last.type === "ReturnStatement" || last.type === "ThrowStatement");
+}
+function isNarrowedByEarlyReturn(node, argExpr, sourceCode) {
+  const argText = sourceCode.getText(argExpr);
+  let current = node.parent;
+  while (current) {
+    if (current.type === "BlockStatement" || current.type === "Program") {
+      for (const stmt of current.body) {
+        if (stmt.range[0] >= node.range[0]) {
+          break;
+        }
+        if (stmt.type === "IfStatement" && stmt.alternate === null && branchTerminates(stmt.consequent)) {
+          const subject = positiveErrorSubject(stmt.test);
+          if (subject && sourceCode.getText(subject) === argText) {
+            return true;
+          }
+        }
+      }
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function nodeWithin(node, container) {
+  return container !== null && node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
+}
+function isGuardedByInstanceofError(node, argExpr, sourceCode) {
+  const argText = sourceCode.getText(argExpr);
+  const sameSubject = (subject) => sourceCode.getText(subject) === argText;
+  let current = node.parent;
+  while (current) {
+    if (current.type === "ConditionalExpression") {
+      const subject = positiveErrorSubject(current.test);
+      if (subject && sameSubject(subject) && nodeWithin(node, current.alternate)) {
+        return true;
+      }
+      const negated = negatedInstanceofErrorSubject(current.test);
+      if (negated && sameSubject(negated) && nodeWithin(node, current.consequent)) {
+        return true;
+      }
+    } else if (current.type === "IfStatement") {
+      const subject = positiveErrorSubject(current.test);
+      if (subject && sameSubject(subject) && nodeWithin(node, current.alternate)) {
+        return true;
+      }
+      const negated = negatedInstanceofErrorSubject(current.test);
+      if (negated && sameSubject(negated) && nodeWithin(node, current.consequent)) {
+        return true;
+      }
+    }
+    current = current.parent;
+  }
+  return false;
+}
 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";
 }
@@ -592,72 +762,124 @@ var no_json_stringify_error_default = import_utils6.ESLintUtils.RuleCreator(
           return;
         }
         const firstArg = node.arguments[0];
-        if (!firstArg || firstArg.type !== "Identifier") {
+        if (!firstArg) {
           return;
         }
-        const name = firstArg.name;
         const scope = context.sourceCode.getScope(firstArg);
-        if (ERROR_NAME_PATTERN.test(name) || isCatchBinding(scope, name)) {
-          context.report({
-            node,
-            messageId: "noJsonStringifyError"
-          });
+        let suggestsError;
+        if (firstArg.type === "Identifier") {
+          suggestsError = ERROR_NAME_PATTERN.test(firstArg.name) || isCatchBinding(scope, firstArg.name);
+        } else if (firstArg.type === "MemberExpression") {
+          suggestsError = memberSuggestsError(firstArg, scope);
+        } else {
+          return;
         }
+        if (!suggestsError) {
+          return;
+        }
+        if (isGuardedByInstanceofError(node, firstArg, context.sourceCode) || isNarrowedByEarlyReturn(node, firstArg, context.sourceCode)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "noJsonStringifyError"
+        });
       }
     };
   }
 });
 
 // src/rules/no-log-only-catch.ts
+var import_utils8 = require("@typescript-eslint/utils");
+
+// src/rules/_logging.ts
 var import_utils7 = require("@typescript-eslint/utils");
-var DEFAULT_IGNORE_PATTERNS2 = [
-  /\.test\./,
-  /\.spec\./,
-  /[\\/]__tests__[\\/]/
-];
-var CONSOLE_METHODS = /* @__PURE__ */ new Set([
-  "log",
-  "error",
-  "warn",
+var LOG_METHODS = /* @__PURE__ */ new Set([
+  "debug",
   "info",
-  "debug"
+  "warn",
+  "warning",
+  "error",
+  "exception",
+  "critical",
+  "trace",
+  "log",
+  "fatal",
+  "success"
 ]);
-function isConsoleCallStatement(statement) {
-  if (statement.type !== "ExpressionStatement") {
-    return false;
+var LOGGER_NAMES = /* @__PURE__ */ new Set([
+  "logger",
+  "log",
+  "logging",
+  "loguru",
+  "console",
+  "_logger",
+  "_log"
+]);
+var REPORT_NAME_RE = /error|report|capture|log|trace|warn/i;
+function isLoggerReceiver(expr) {
+  switch (expr.type) {
+    case "Identifier":
+      return LOGGER_NAMES.has(expr.name.toLowerCase());
+    case "MemberExpression": {
+      const { property, object } = expr;
+      if (!expr.computed && property.type === "Identifier" && LOGGER_NAMES.has(property.name.toLowerCase())) {
+        return true;
+      }
+      return isLoggerReceiver(object);
+    }
+    default:
+      return false;
   }
-  const expr = statement.expression;
+}
+function isLoggingCall(expr) {
   if (expr.type !== "CallExpression") {
     return false;
   }
   const callee = expr.callee;
-  if (callee.type !== "MemberExpression") {
+  if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") {
     return false;
   }
-  const { object, property } = callee;
-  if (object.type !== "Identifier" || object.name !== "console") {
+  if (!LOG_METHODS.has(callee.property.name.toLowerCase())) {
     return false;
   }
-  if (callee.computed) {
-    return false;
+  return isLoggerReceiver(callee.object);
+}
+function calleeName(callee) {
+  if (callee.type === "Identifier") {
+    return callee.name;
+  }
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
   }
-  if (property.type !== "Identifier") {
+  return null;
+}
+
+// src/rules/no-log-only-catch.ts
+var DEFAULT_IGNORE_PATTERNS2 = [
+  /\.test\./,
+  /\.spec\./,
+  /[\\/]__tests__[\\/]/
+];
+function isLoggingCallStatement(statement) {
+  if (statement.type !== "ExpressionStatement") {
     return false;
   }
-  return CONSOLE_METHODS.has(property.name);
+  return isLoggingCall(statement.expression);
 }
-var no_log_only_catch_default = import_utils7.ESLintUtils.RuleCreator(
+var no_log_only_catch_default = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-log-only-catch",
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow `catch` clauses that only log (or do nothing) and then swallow the error; rethrow or handle it instead."
+      description: "Disallow `catch` clauses that only log (or silently do nothing) and then swallow the error; rethrow or handle it instead."
     },
     schema: [],
     messages: {
-      noLogOnlyCatch: "Logging then swallowing the error hides failures. Rethrow the error or handle it for real."
+      noLogOnlyCatch: "Logging then swallowing the error hides failures. Rethrow the error or handle it for real.",
+      emptyCatch: "Empty catch silently swallows the error. Rethrow it, handle it, or add a comment explaining why it is safe to ignore."
     }
   },
   defaultOptions: [],
@@ -673,13 +895,16 @@ var no_log_only_catch_default = import_utils7.ESLintUtils.RuleCreator(
       CatchClause(node) {
         const statements = node.body.body;
         if (statements.length === 0) {
-          context.report({ node, messageId: "noLogOnlyCatch" });
+          if (context.sourceCode.getCommentsInside(node.body).length > 0) {
+            return;
+          }
+          context.report({ node, messageId: "emptyCatch" });
           return;
         }
-        const everyStatementIsConsoleLog = statements.every(
-          (statement) => isConsoleCallStatement(statement)
+        const everyStatementIsLogging = statements.every(
+          (statement) => isLoggingCallStatement(statement)
         );
-        if (everyStatementIsConsoleLog) {
+        if (everyStatementIsLogging) {
           context.report({ node, messageId: "noLogOnlyCatch" });
         }
       }
@@ -688,8 +913,25 @@ var no_log_only_catch_default = import_utils7.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-env.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var no_raw_env_default = import_utils8.ESLintUtils.RuleCreator(
+var import_utils9 = require("@typescript-eslint/utils");
+function isProcessEnv(node) {
+  return !node.computed && node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
+}
+function isImportMetaEnv(node) {
+  return !node.computed && node.property.type === "Identifier" && node.property.name === "env" && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta";
+}
+var BUILD_TIME_CONSTANTS = /* @__PURE__ */ new Set([
+  "NODE_ENV",
+  "MODE",
+  "DEV",
+  "PROD",
+  "SSR"
+]);
+function isBuildTimeConstantAccess(node) {
+  const parent = node.parent;
+  return parent.type === "MemberExpression" && parent.object === node && !parent.computed && parent.property.type === "Identifier" && BUILD_TIME_CONSTANTS.has(parent.property.name);
+}
+var no_raw_env_default = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-env",
@@ -707,10 +949,7 @@ var no_raw_env_default = import_utils8.ESLintUtils.RuleCreator(
   create(context) {
     return {
       MemberExpression(node) {
-        if (node.computed) {
-          return;
-        }
-        if (node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env") {
+        if ((isProcessEnv(node) || isImportMetaEnv(node)) && !isBuildTimeConstantAccess(node)) {
           context.report({
             node,
             messageId: "noRawEnv"
@@ -722,39 +961,72 @@ var no_raw_env_default = import_utils8.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-var import_utils9 = require("@typescript-eslint/utils");
+var import_utils10 = require("@typescript-eslint/utils");
+function sentinelKind(arg) {
+  if (arg === null) {
+    return null;
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.Literal) {
+    if (arg.value === null) {
+      return "nullish";
+    }
+    if (typeof arg.value === "boolean") {
+      return "boolean";
+    }
+    if (typeof arg.value === "string") {
+      return "string";
+    }
+    return null;
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+    return "nullish";
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.ArrayExpression) {
+    return "array";
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.ObjectExpression) {
+    return "object";
+  }
+  return null;
+}
 function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
   }
-  if (arg.type === import_utils9.AST_NODE_TYPES.Literal && arg.value === null) {
+  if (arg.type === import_utils10.AST_NODE_TYPES.Literal && arg.value === null) {
     return true;
   }
-  if (arg.type === import_utils9.AST_NODE_TYPES.Literal && arg.value === false) {
+  if (arg.type === import_utils10.AST_NODE_TYPES.Literal && arg.value === false) {
     return true;
   }
-  if (arg.type === import_utils9.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (arg.type === import_utils10.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
     return true;
   }
-  if (arg.type === import_utils9.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
+  if (arg.type === import_utils10.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
     return true;
   }
-  if (arg.type === import_utils9.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
+  if (arg.type === import_utils10.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
     return true;
   }
   return false;
 }
-function containsThrow(node) {
+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;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function walkWithinScope(node, visit) {
   let found = false;
-  const visit = (current) => {
+  const recurse = (current) => {
     if (found) {
       return;
     }
-    if (current.type === import_utils9.AST_NODE_TYPES.ThrowStatement) {
+    if (visit(current)) {
       found = true;
       return;
     }
-    if (current.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils9.AST_NODE_TYPES.FunctionExpression || current.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (isFunctionNode(current)) {
       return;
     }
     for (const key of Object.keys(current)) {
@@ -765,32 +1037,111 @@ function containsThrow(node) {
       if (Array.isArray(value)) {
         for (const child of value) {
           if (isNode(child)) {
-            visit(child);
+            recurse(child);
           }
         }
       } else if (isNode(value)) {
-        visit(value);
+        recurse(value);
       }
     }
   };
-  visit(node);
+  recurse(node);
   return found;
 }
-function isNode(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string";
+function containsThrow(node) {
+  return walkWithinScope(
+    node,
+    (current) => current.type === import_utils10.AST_NODE_TYPES.ThrowStatement
+  );
 }
-var no_sentinel_return_on_catch_default = import_utils9.ESLintUtils.RuleCreator(
+function argsIncludeBinding(args, caughtName) {
+  if (caughtName === null) {
+    return false;
+  }
+  return args.some(
+    (arg) => arg.type === import_utils10.AST_NODE_TYPES.Identifier && arg.name === caughtName
+  );
+}
+function logsOrReportsError(catchBody, caughtName) {
+  return walkWithinScope(catchBody, (current) => {
+    if (current.type !== import_utils10.AST_NODE_TYPES.CallExpression) {
+      return false;
+    }
+    if (isLoggingCall(current)) {
+      return true;
+    }
+    const name = calleeName(current.callee);
+    return name !== null && REPORT_NAME_RE.test(name) && argsIncludeBinding(current.arguments, caughtName);
+  });
+}
+function tryBlockOf(catchNode) {
+  return catchNode.parent.block;
+}
+function isSafeParseExpression(arg) {
+  if (arg === null) {
+    return false;
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.CallExpression && arg.callee.type === import_utils10.AST_NODE_TYPES.MemberExpression && !arg.callee.computed && arg.callee.property.type === import_utils10.AST_NODE_TYPES.Identifier && arg.callee.property.name === "parse") {
+    return true;
+  }
+  if (arg.type === import_utils10.AST_NODE_TYPES.NewExpression && arg.callee.type === import_utils10.AST_NODE_TYPES.Identifier) {
+    return arg.callee.name === "RegExp" || arg.callee.name === "URL";
+  }
+  return false;
+}
+function tryReturnsSafeParse(catchNode) {
+  return walkWithinScope(
+    tryBlockOf(catchNode),
+    (current) => current.type === import_utils10.AST_NODE_TYPES.ReturnStatement && isSafeParseExpression(current.argument)
+  );
+}
+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) {
+      return current.body;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
+  const functionBody = enclosingFunctionBody(catchNode);
+  if (functionBody === null) {
+    return false;
+  }
+  return walkWithinScope(functionBody, (current) => {
+    if (current.type !== import_utils10.AST_NODE_TYPES.ReturnStatement) {
+      return false;
+    }
+    if (isWithin(current, catchNode.body)) {
+      return false;
+    }
+    return sentinelKind(current.argument) === kind;
+  });
+}
+function isWithin(node, ancestor) {
+  let current = node;
+  while (current !== void 0 && current !== null) {
+    if (current === ancestor) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+var no_sentinel_return_on_catch_default = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sentinel-return-on-catch",
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow swallowing a caught error by returning an empty sentinel (`null`, `undefined`, `false`, `[]`, `{}`) as the final statement of a `catch` block."
+      description: "Disallow swallowing a caught error by returning an empty sentinel (`null`, `undefined`, `false`, `[]`, `{}`) as the final statement of a `catch` block, unless the error is logged/reported or the sentinel is the declared safe-parse/predicate contract."
     },
     schema: [],
     messages: {
-      noSentinelReturn: "This `catch` block swallows the error by returning an empty sentinel. Rethrow it, return a typed Result, or handle the error explicitly."
+      noSentinelReturn: "This `catch` block swallows the error by returning an empty sentinel without logging it. Rethrow it, log/report it, or return a typed Result."
     }
   },
   defaultOptions: [],
@@ -802,7 +1153,7 @@ var no_sentinel_return_on_catch_default = import_utils9.ESLintUtils.RuleCreator(
           return;
         }
         const last = body[body.length - 1];
-        if (last === void 0 || last.type !== import_utils9.AST_NODE_TYPES.ReturnStatement) {
+        if (last === void 0 || last.type !== import_utils10.AST_NODE_TYPES.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -811,6 +1162,17 @@ var no_sentinel_return_on_catch_default = import_utils9.ESLintUtils.RuleCreator(
         if (containsThrow(node.body)) {
           return;
         }
+        const caughtName = node.param?.type === import_utils10.AST_NODE_TYPES.Identifier ? node.param.name : null;
+        if (logsOrReportsError(node.body, caughtName)) {
+          return;
+        }
+        if (tryReturnsSafeParse(node)) {
+          return;
+        }
+        const kind = sentinelKind(last.argument);
+        if (kind !== null && functionReturnsSameSentinelKindElsewhere(node, kind)) {
+          return;
+        }
         context.report({
           node: last,
           messageId: "noSentinelReturn"
@@ -821,14 +1183,112 @@ var no_sentinel_return_on_catch_default = import_utils9.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sequential-await.ts
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils11 = 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|\bstage|\bstep|\bphase|migration|chain|buffer|stream|teleport|chunk|\bqueue|drain/i;
 function isFunctionLike(node) {
   return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
 }
 function isLoop(node) {
   return node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
 }
-var no_sequential_await_default = import_utils10.ESLintUtils.RuleCreator(
+function isNode2(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function visitScope(root, visit) {
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "parent") {
+      continue;
+    }
+    const value = root[key];
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      if (isNode2(child) && !isFunctionLike(child) && !isLoop(child)) {
+        visitScope(child, visit);
+      }
+    }
+  }
+}
+function collectAwaits(root) {
+  const awaits = [];
+  visitScope(root, (node) => {
+    if (node.type === "AwaitExpression") {
+      awaits.push(node);
+    }
+  });
+  return awaits;
+}
+function hasEarlyExit(root) {
+  let found = false;
+  visitScope(root, (node) => {
+    if (node.type === "ReturnStatement" || node.type === "BreakStatement" || node.type === "ContinueStatement") {
+      found = true;
+    }
+  });
+  return found;
+}
+var TIMER_HELPER_RE = /^(sleep|timeout|delay|wait|pause|tick)$/i;
+function calleeName2(callee) {
+  if (callee.type === "Identifier") return callee.name;
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+}
+function isTimerYield(node) {
+  const arg = node.argument;
+  if (arg.type === "NewExpression" && arg.callee.type === "Identifier" && arg.callee.name === "Promise") {
+    return true;
+  }
+  if (arg.type === "CallExpression") {
+    const name = calleeName2(arg.callee);
+    return name !== null && TIMER_HELPER_RE.test(name);
+  }
+  return false;
+}
+var QUEUE_DRAIN_METHODS = /^(shift|pop|dequeue|next|poll)$/;
+function isQueueDrain(node) {
+  const arg = node.argument;
+  return arg.type === "CallExpression" && arg.callee.type === "MemberExpression" && !arg.callee.computed && arg.callee.property.type === "Identifier" && QUEUE_DRAIN_METHODS.test(arg.callee.property.name);
+}
+function referencesName(root, name) {
+  let found = false;
+  visitScope(root, (node) => {
+    if (node.type === "Identifier" && node.name === name) {
+      found = true;
+    }
+  });
+  return found;
+}
+function isThreadedAccumulator(node) {
+  const parent = node.parent;
+  let target = null;
+  if (parent.type === "AssignmentExpression" && parent.operator === "=" && parent.right === node && parent.left.type === "Identifier") {
+    target = parent.left.name;
+  } else if (parent.type === "VariableDeclarator" && parent.init === node && parent.id.type === "Identifier") {
+    target = parent.id.name;
+  }
+  if (target === null) {
+    return false;
+  }
+  return referencesName(node.argument, target);
+}
+function shouldReport(awaits, earlyExit, iterableText) {
+  if (awaits.length === 0) {
+    return false;
+  }
+  if (earlyExit) {
+    return false;
+  }
+  if (iterableText !== null && SEQUENTIAL_ITERABLE_HINT.test(iterableText)) {
+    return false;
+  }
+  return awaits.some(
+    (node) => !isTimerYield(node) && !isThreadedAccumulator(node) && !isQueueDrain(node)
+  );
+}
+var no_sequential_await_default = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sequential-await",
@@ -844,53 +1304,35 @@ var no_sequential_await_default = import_utils10.ESLintUtils.RuleCreator(
   },
   defaultOptions: [],
   create(context) {
-    function findAwaitInScope(node) {
-      if (node.type === "AwaitExpression") {
-        return node;
+    function loopParts(node) {
+      if (node.type === "ForStatement") {
+        return [node.body, node.test, node.update];
       }
-      if (isFunctionLike(node)) {
-        return null;
+      if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
+        return [node.body];
       }
-      for (const key of Object.keys(node)) {
-        if (key === "parent") {
-          continue;
-        }
-        const value = node[key];
-        if (Array.isArray(value)) {
-          for (const child of value) {
-            if (isNode4(child) && !isLoop(child)) {
-              const found = findAwaitInScope(child);
-              if (found) {
-                return found;
-              }
-            }
-          }
-        } else if (isNode4(value) && !isLoop(value)) {
-          const found = findAwaitInScope(value);
-          if (found) {
-            return found;
-          }
-        }
+      return [node.body, node.test];
+    }
+    function iterableTextOf(node) {
+      if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
+        return context.sourceCode.getText(node.right);
       }
       return null;
     }
-    function isNode4(value) {
-      return typeof value === "object" && value !== null && typeof value.type === "string";
-    }
     function checkLoop(node) {
-      const parts = [node.body];
-      if (node.type === "ForStatement") {
-        parts.push(node.init, node.test, node.update);
-      } else if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
-        parts.push(node.right);
-      } else {
-        parts.push(node.test);
-      }
-      for (const part of parts) {
-        if (part && !isLoop(part) && findAwaitInScope(part)) {
-          context.report({ node, messageId: "noSequentialAwait" });
-          return;
+      const awaits = [];
+      let earlyExit = false;
+      for (const part of loopParts(node)) {
+        if (part === null || isLoop(part)) {
+          continue;
         }
+        awaits.push(...collectAwaits(part));
+        if (!earlyExit && hasEarlyExit(part)) {
+          earlyExit = true;
+        }
+      }
+      if (shouldReport(awaits, earlyExit, iterableTextOf(node))) {
+        context.report({ node, messageId: "noSequentialAwait" });
       }
     }
     return {
@@ -903,13 +1345,35 @@ var no_sequential_await_default = import_utils10.ESLintUtils.RuleCreator(
           return;
         }
         checkLoop(node);
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression" || callee.computed) {
+          return;
+        }
+        if (callee.property.type !== "Identifier" || !ARRAY_ITERATION_METHODS.has(callee.property.name)) {
+          return;
+        }
+        const callback = node.arguments[0];
+        if (callback === void 0 || !isFunctionLike(callback) || !("async" in callback && callback.async)) {
+          return;
+        }
+        if (callee.property.name !== "forEach" && node.parent.type !== "ExpressionStatement") {
+          return;
+        }
+        const awaits = collectAwaits(callback.body);
+        const earlyExit = hasEarlyExit(callback.body);
+        const iterableText = context.sourceCode.getText(callee.object);
+        if (shouldReport(awaits, earlyExit, iterableText)) {
+          context.report({ node, messageId: "noSequentialAwait" });
+        }
       }
     };
   }
 });
 
 // src/rules/no-string-concat-in-loop.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -954,6 +1418,21 @@ function isStringInitializedVariable(variable) {
   }
   return isStringLiteralInit(declarator.init);
 }
+function isConcatOperand(node, target) {
+  if (node.type === "Identifier") {
+    return node.name === target;
+  }
+  if (node.type === "BinaryExpression" && node.operator === "+") {
+    return isConcatOperand(node.left, target) || isConcatOperand(node.right, target);
+  }
+  return false;
+}
+function isConcatOntoTarget(rhs, target) {
+  if (rhs.type !== "BinaryExpression" || rhs.operator !== "+") {
+    return false;
+  }
+  return isConcatOperand(rhs.left, target) || isConcatOperand(rhs.right, target);
+}
 function isInsideLoopBody(node) {
   let child = node;
   let parent = node.parent;
@@ -969,7 +1448,7 @@ function isInsideLoopBody(node) {
   }
   return false;
 }
-var no_string_concat_in_loop_default = import_utils11.ESLintUtils.RuleCreator(
+var no_string_concat_in_loop_default = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-string-concat-in-loop",
@@ -987,10 +1466,11 @@ var no_string_concat_in_loop_default = import_utils11.ESLintUtils.RuleCreator(
   create(context) {
     return {
       AssignmentExpression(node) {
-        if (node.operator !== "+=") {
+        if (node.left.type !== "Identifier") {
           return;
         }
-        if (node.left.type !== "Identifier") {
+        const isAccumulation = node.operator === "+=" || node.operator === "=" && isConcatOntoTarget(node.right, node.left.name);
+        if (!isAccumulation) {
           return;
         }
         if (!isInsideLoopBody(node)) {
@@ -1014,7 +1494,7 @@ var no_string_concat_in_loop_default = import_utils11.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -1037,16 +1517,16 @@ var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
 ]);
 var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-day-picker|@floating-ui\/|react-select|react-toastify|react-hook-form|recharts|react-dropzone|react-slick|react-swipeable|react-resizable|react-draggable|react-beautiful-dnd|@hello-pangea\/dnd|react-virtualized|react-window|@tanstack\/react-table|@tanstack\/react-query|react-redux|recoil|jotai|zustand|@tippyjs\/react|react-color|react-datepicker|next-themes|react-helmet|react-helmet-async|styled-components|@emotion\/)/;
 var isUseClientDirective = (node) => {
-  return node.type === import_utils12.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils12.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils13.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils13.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils12.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils13.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils12.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils13.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -1063,7 +1543,7 @@ var isGlobalReference = (node, context) => {
   }
   return true;
 };
-var no_unnecessary_use_client_default = import_utils12.ESLintUtils.RuleCreator(
+var no_unnecessary_use_client_default = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unnecessary-use-client",
@@ -1086,13 +1566,13 @@ var no_unnecessary_use_client_default = import_utils12.ESLintUtils.RuleCreator(
     let directiveNode = null;
     let hasClientIndicator = false;
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils12.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils13.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils12.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils12.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils13.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -1102,7 +1582,7 @@ var no_unnecessary_use_client_default = import_utils12.ESLintUtils.RuleCreator(
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils12.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils13.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -1115,7 +1595,7 @@ var no_unnecessary_use_client_default = import_utils12.ESLintUtils.RuleCreator(
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils12.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils13.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -1164,8 +1644,8 @@ var no_unnecessary_use_client_default = import_utils12.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-discriminated-union.ts
-var import_utils13 = require("@typescript-eslint/utils");
 var import_utils14 = require("@typescript-eslint/utils");
+var import_utils15 = require("@typescript-eslint/utils");
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -1175,26 +1655,26 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils14.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils15.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils14.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils15.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils14.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils15.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils14.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils15.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== import_utils14.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils15.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -1207,7 +1687,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   }
   return hasStatusBoolean && optionalCount >= MIN_OPTIONAL_MEMBERS;
 }
-var prefer_discriminated_union_default = import_utils13.ESLintUtils.RuleCreator(
+var prefer_discriminated_union_default = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-discriminated-union",
@@ -1235,7 +1715,7 @@ var prefer_discriminated_union_default = import_utils13.ESLintUtils.RuleCreator(
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils14.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils15.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -1248,13 +1728,13 @@ var prefer_discriminated_union_default = import_utils13.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils15 = require("@typescript-eslint/utils");
+var import_utils16 = require("@typescript-eslint/utils");
 var unwrap = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils15.AST_NODE_TYPES.TSAsExpression || current.type === import_utils15.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils15.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils15.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils16.AST_NODE_TYPES.TSAsExpression || current.type === import_utils16.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils16.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils16.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils15.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils16.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -1265,18 +1745,18 @@ var unwrap = (node) => {
 var isJsonCall = (node) => {
   let current = unwrap(node);
   if (current === null) return false;
-  if (current.type === import_utils15.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils16.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap(current.argument);
   }
-  if (current === null || current.type !== import_utils15.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils16.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap(current.callee);
-  if (callee === null || callee.type !== import_utils15.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils16.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap(callee.property);
-  return property !== null && property.type === import_utils15.AST_NODE_TYPES.Identifier && property.name === "json";
+  return property !== null && property.type === import_utils16.AST_NODE_TYPES.Identifier && property.name === "json";
 };
 var findVariable2 = (scope, name) => {
   let current = scope;
@@ -1287,15 +1767,39 @@ var findVariable2 = (scope, name) => {
   }
   return null;
 };
+var GUARD_NAME_RE = /^is[A-Z]/;
+var isGuardTestPosition = (node) => {
+  let current = 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:
+        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:
+        return parent.test === current;
+      default:
+        return false;
+    }
+  }
+  return false;
+};
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
-  if (unwrapped === null || unwrapped.type !== import_utils15.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
   return variable !== null && tracked.has(variable);
 };
-var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreator(
+var prefer_schema_for_api_payload_default = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-schema-for-api-payload",
@@ -1323,11 +1827,11 @@ var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreat
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils15.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils15.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils15.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
           if (isJsonCall(node.init)) {
             context.report({ node: node.id, messageId: "unparsedJsonAccess" });
             return;
@@ -1339,7 +1843,7 @@ var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreat
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils15.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils16.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isJsonCall(node.right)) {
@@ -1349,7 +1853,7 @@ var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreat
           }
           return;
         }
-        if (node.left.type === import_utils15.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils15.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils16.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils16.AST_NODE_TYPES.ArrayPattern) {
           if (isJsonCall(node.right)) {
             context.report({
               node: node.left,
@@ -1365,18 +1869,34 @@ var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreat
           }
         }
       },
+      CallExpression(node) {
+        if (node.callee.type !== import_utils16.AST_NODE_TYPES.Identifier) return;
+        if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        for (const arg of node.arguments) {
+          if (arg.type === import_utils16.AST_NODE_TYPES.SpreadElement) continue;
+          const unwrapped = unwrap(arg);
+          if (unwrapped === null || unwrapped.type !== import_utils16.AST_NODE_TYPES.Identifier) {
+            continue;
+          }
+          const variable = findVariable2(scope, unwrapped.name);
+          if (variable !== null) unvalidatedVariables.delete(variable);
+        }
+      },
       MemberExpression(node) {
         const scope = context.sourceCode.getScope(node);
         const obj = unwrap(node.object);
         if (isJsonCall(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils15.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils15.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
+          if (parent.type === import_utils16.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils16.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils15.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils16.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -1389,7 +1909,7 @@ var prefer_schema_for_api_payload_default = import_utils15.ESLintUtils.RuleCreat
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils16 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 
 // src/rules/_tailwind.ts
 var tailwindBase = (token) => token.replace(/^(?:[a-z0-9-]+:)+/i, "").replace(/^!/, "");
@@ -1426,12 +1946,41 @@ var STYLE_COLOR_PROPS = /* @__PURE__ */ new Set([
   "lightingColor"
 ]);
 var RAW_COLOR_VALUE_RE = new RegExp(`#[0-9a-fA-F]{3,8}\\b|\\b(?:${COLOR_FN})\\s*\\(`, "i");
+var STORIES_FILE_RE = /\.stories\.[cm]?[jt]sx?$/i;
+var SVG_DEFS_CONTAINERS = /* @__PURE__ */ new Set([
+  "mask",
+  "clipPath",
+  "defs",
+  "pattern",
+  "linearGradient",
+  "radialGradient"
+]);
+var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
+  "#fff",
+  "#ffffff",
+  "#000",
+  "#000000",
+  "transparent",
+  "none",
+  "currentcolor",
+  "inherit"
+]);
+var isInsideSvg = (node) => {
+  let current = node.parent;
+  while (current !== void 0 && current !== null) {
+    if (current.type === import_utils17.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils17.AST_NODE_TYPES.JSXIdentifier && (current.openingElement.name.name === "svg" || SVG_DEFS_CONTAINERS.has(current.openingElement.name.name))) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+};
 var propName = (key) => {
-  if (key.type === import_utils16.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils16.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils17.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils17.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
-var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
+var prefer_semantic_colors_default = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-semantic-colors",
@@ -1449,6 +1998,7 @@ var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
   },
   defaultOptions: [],
   create(context) {
+    if (STORIES_FILE_RE.test(context.filename)) return {};
     const reportClasses = (value, node) => {
       for (const token of classTokens(value)) {
         const base = tailwindBase(token);
@@ -1462,27 +2012,27 @@ var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils16.AST_NODE_TYPES.Literal:
+        case import_utils17.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils16.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils17.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils16.AST_NODE_TYPES.ArrayExpression:
+        case import_utils17.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils16.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils16.AST_NODE_TYPES.ObjectExpression:
+        case import_utils17.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils16.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils17.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils16.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils17.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils16.AST_NODE_TYPES.LogicalExpression:
+        case import_utils17.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -1490,29 +2040,29 @@ var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils16.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
+      if (node.type === import_utils17.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
         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_utils16.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils16.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils16.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils17.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils17.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils17.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils16.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils16.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils17.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils16.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -1520,9 +2070,16 @@ var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
         const name = propName(node.key);
         if (name !== null && CLASS_NAME_RE.test(name)) checkClassNode(node.value);
       },
-      // SVG presentation attributes: <path fill="#000" stroke="#fff" />
+      // SVG presentation attributes: <path fill="#7c3aed" stroke="#7c3aed" />.
+      // 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_utils16.AST_NODE_TYPES.Literal) checkColorValueNode(node.value);
+        if (node.value?.type !== import_utils17.AST_NODE_TYPES.Literal) return;
+        if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
+          return;
+        }
+        if (isInsideSvg(node)) return;
+        checkColorValueNode(node.value);
       },
       // Inline style objects: style={{ color: "#111827", backgroundColor: "#fff" }}
       "JSXAttribute[name.name='style'] ObjectExpression > Property"(node) {
@@ -1534,7 +2091,7 @@ var prefer_semantic_colors_default = import_utils16.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
@@ -1613,7 +2170,7 @@ function getPropertyNode(objNode, propName2) {
   }
   return null;
 }
-var prefer_server_actions_default = import_utils17.ESLintUtils.RuleCreator(
+var prefer_server_actions_default = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-server-actions",
@@ -1681,14 +2238,38 @@ var prefer_server_actions_default = import_utils17.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-shadcn.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 var REPLACEMENTS = {
-  input: "Input",
   select: "Select",
   textarea: "Textarea",
   dialog: "Dialog"
 };
-var prefer_shadcn_default = import_utils18.ESLintUtils.RuleCreator(
+var INPUT_TYPE_REPLACEMENTS = {
+  checkbox: "Checkbox",
+  radio: "RadioGroup",
+  range: "Slider"
+};
+var SKIPPED_INPUT_TYPES = /* @__PURE__ */ new Set(["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") {
+      continue;
+    }
+    if (attribute.value?.type === import_utils19.AST_NODE_TYPES.Literal && typeof attribute.value.value === "string") {
+      return { kind: "literal", value: attribute.value.value.toLowerCase() };
+    }
+    return { kind: "dynamic" };
+  }
+  return null;
+};
+var resolveInputReplacement = (node) => {
+  const typeAttr = literalTypeAttr(node);
+  if (typeAttr === null || typeAttr.kind === "dynamic") return "Input";
+  if (SKIPPED_INPUT_TYPES.has(typeAttr.value)) return null;
+  return INPUT_TYPE_REPLACEMENTS[typeAttr.value] ?? "Input";
+};
+var prefer_shadcn_default = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-shadcn",
@@ -1710,8 +2291,8 @@ var prefer_shadcn_default = import_utils18.ESLintUtils.RuleCreator(
           return;
         }
         const elementName = node.name.name;
-        const replacement = REPLACEMENTS[elementName];
-        if (replacement === void 0) {
+        const replacement = elementName === "input" ? resolveInputReplacement(node) : REPLACEMENTS[elementName];
+        if (replacement === void 0 || replacement === null) {
           return;
         }
         context.report({
@@ -1720,7 +2301,7 @@ var prefer_shadcn_default = import_utils18.ESLintUtils.RuleCreator(
           data: {
             element: elementName,
             replacement,
-            lowercase: elementName
+            lowercase: kebabCase(replacement)
           }
         });
       }
@@ -1729,41 +2310,57 @@ var prefer_shadcn_default = import_utils18.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-assert-never.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils19.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === import_utils19.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return callee.name === "assertNever";
   }
-  if (callee.type === import_utils19.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils19.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils20.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "assertNever";
   }
   return false;
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === import_utils19.AST_NODE_TYPES.ExpressionStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils19.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils19.AST_NODE_TYPES.ReturnStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils19.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils19.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils19.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
 };
-var require_assert_never_default = import_utils19.ESLintUtils.RuleCreator(
+var isFallthroughDefault = (node, defaultIndex) => {
+  const defaultCase = node.cases[defaultIndex];
+  return defaultCase !== void 0 && defaultCase.consequent.length === 0 && defaultIndex < node.cases.length - 1;
+};
+var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
+  if (defaultCase.consequent.length === 0) {
+    const defaultToken = sourceCode.getFirstToken(defaultCase);
+    const colonToken = defaultToken ? sourceCode.getTokenAfter(defaultToken) : null;
+    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) {
+    return sourceCode.getCommentsInside(only).length > 0;
+  }
+  return false;
+};
+var require_assert_never_default = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-assert-never",
@@ -1781,12 +2378,16 @@ var require_assert_never_default = import_utils19.ESLintUtils.RuleCreator(
   create(context) {
     return {
       SwitchStatement(node) {
-        const defaultCase = node.cases.find(
+        const defaultIndex = node.cases.findIndex(
           (caseNode) => caseNode.test === null
         );
-        if (!defaultCase) return;
+        if (defaultIndex === -1) return;
+        const defaultCase = node.cases[defaultIndex];
+        if (defaultCase === void 0) return;
         if (defaultCase.consequent.some(statementContainsAssertNever)) return;
         if (defaultCase.consequent.some(isRuntimeHandlingStatement)) return;
+        if (isFallthroughDefault(node, defaultIndex)) return;
+        if (isCommentOnlyNoopDefault(defaultCase, context.sourceCode)) return;
         context.report({
           node: defaultCase,
           messageId: "missingAssertNever"
@@ -1797,19 +2398,19 @@ var require_assert_never_default = import_utils19.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils20.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils21.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils20.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils21.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils20.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -1817,25 +2418,25 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils21.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_utils20.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils21.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils20.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils20.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils21.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils21.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
-var require_zod_form_validation_default = import_utils20.ESLintUtils.RuleCreator(
+var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-zod-form-validation",
@@ -1852,14 +2453,14 @@ var require_zod_form_validation_default = import_utils20.ESLintUtils.RuleCreator
   defaultOptions: [],
   create(context) {
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils21.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_utils20.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils21.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -1870,8 +2471,8 @@ var require_zod_form_validation_default = import_utils20.ESLintUtils.RuleCreator
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils20.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      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") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -1894,15 +2495,15 @@ var require_zod_form_validation_default = import_utils20.ESLintUtils.RuleCreator
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils22.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils21.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils22.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils21.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils22.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -1910,7 +2511,7 @@ var calleeChainStartsWithZ = (node) => {
   }
   return false;
 };
-var zod_naming_convention_default = import_utils21.ESLintUtils.RuleCreator(
+var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "zod-naming-convention",
@@ -1930,11 +2531,11 @@ var zod_naming_convention_default = import_utils21.ESLintUtils.RuleCreator(
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils21.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils22.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
-        if (node.id.type !== import_utils21.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils22.AST_NODE_TYPES.Identifier) return;
         const variableName = node.id.name;
         if (variableName.startsWith("Z")) return;
         context.report({
@@ -1947,7 +2548,7 @@ var zod_naming_convention_default = import_utils21.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-cors-wildcard-with-credentials.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils23 = 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"]);
@@ -1979,17 +2580,17 @@ function subtreeContainsStarLiteral(node) {
     const value = node[key];
     if (Array.isArray(value)) {
       for (const child of value) {
-        if (isNode2(child) && subtreeContainsStarLiteral(child)) {
+        if (isNode3(child) && subtreeContainsStarLiteral(child)) {
           return true;
         }
       }
-    } else if (isNode2(value) && subtreeContainsStarLiteral(value)) {
+    } else if (isNode3(value) && subtreeContainsStarLiteral(value)) {
       return true;
     }
   }
   return false;
 }
-function isNode2(value) {
+function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 function propertyKeyName(prop) {
@@ -2005,7 +2606,7 @@ function propertyKeyName(prop) {
   }
   return void 0;
 }
-function calleeName(node) {
+function calleeName3(node) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
     return callee.name;
@@ -2016,7 +2617,7 @@ function calleeName(node) {
   return void 0;
 }
 function isCorsWildcardCredentialsCall(node) {
-  const name = calleeName(node);
+  const name = calleeName3(node);
   if (name === void 0 || name.toLowerCase() !== "cors") {
     return false;
   }
@@ -2089,7 +2690,7 @@ function enclosingScope(node) {
   }
   return void 0;
 }
-var no_cors_wildcard_with_credentials_default = import_utils22.ESLintUtils.RuleCreator(
+var no_cors_wildcard_with_credentials_default = import_utils23.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-cors-wildcard-with-credentials",
@@ -2157,12 +2758,12 @@ var no_cors_wildcard_with_credentials_default = import_utils22.ESLintUtils.RuleC
 });
 
 // src/rules/no-fat-try-blocks.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils23.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils23.AST_NODE_TYPES.FunctionExpression,
-  import_utils23.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils24.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils24.AST_NODE_TYPES.FunctionExpression,
+  import_utils24.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -2255,25 +2856,25 @@ var PURE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "Response",
   "AbortController"
 ]);
-function isNode3(value) {
+function isNode4(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 function isPureCall(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== import_utils23.AST_NODE_TYPES.Identifier) {
+  if (property.type !== import_utils24.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  if (callee.object.type === import_utils23.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === import_utils24.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_utils23.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === import_utils24.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
 function subtreeMatches(stmt, predicate) {
   let found = false;
@@ -2295,11 +2896,11 @@ function subtreeMatches(stmt, predicate) {
       const value = current[key];
       if (Array.isArray(value)) {
         for (const child of value) {
-          if (isNode3(child)) {
+          if (isNode4(child)) {
             visit(child);
           }
         }
-      } else if (isNode3(value)) {
+      } else if (isNode4(value)) {
         visit(value);
       }
       if (found) {
@@ -2310,14 +2911,14 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === import_utils23.AST_NODE_TYPES.AwaitExpression);
+var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === import_utils24.AST_NODE_TYPES.AwaitExpression);
 var hasThrowingCallOrNew = (stmt) => subtreeMatches(
   stmt,
-  (n) => n.type === import_utils23.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils23.AST_NODE_TYPES.NewExpression && !isPureNew(n)
+  (n) => n.type === import_utils24.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils24.AST_NODE_TYPES.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === import_utils23.AST_NODE_TYPES.ChainExpression || current.type === import_utils23.AST_NODE_TYPES.TSNonNullExpression) {
+  while (current.type === import_utils24.AST_NODE_TYPES.ChainExpression || current.type === import_utils24.AST_NODE_TYPES.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
@@ -2326,7 +2927,7 @@ function canThrow(stmt) {
   if (hasAwait(stmt)) {
     return true;
   }
-  if (stmt.type === import_utils23.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils23.AST_NODE_TYPES.CallExpression) {
+  if (stmt.type === import_utils24.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils24.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   return hasThrowingCallOrNew(stmt);
@@ -2337,9 +2938,9 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === import_utils23.AST_NODE_TYPES.ThrowStatement;
+  return last !== void 0 && last.type === import_utils24.AST_NODE_TYPES.ThrowStatement;
 }
-var no_fat_try_blocks_default = import_utils23.ESLintUtils.RuleCreator(
+var no_fat_try_blocks_default = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-fat-try-blocks",
@@ -2380,8 +2981,8 @@ var no_fat_try_blocks_default = import_utils23.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils24 = require("@typescript-eslint/utils");
-var LOG_METHODS = /* @__PURE__ */ new Set([
+var import_utils25 = require("@typescript-eslint/utils");
+var LOG_METHODS2 = /* @__PURE__ */ new Set([
   "debug",
   "info",
   "warn",
@@ -2394,7 +2995,7 @@ var LOG_METHODS = /* @__PURE__ */ new Set([
   "fatal",
   "success"
 ]);
-var LOGGER_NAMES = /* @__PURE__ */ new Set([
+var LOGGER_NAMES2 = /* @__PURE__ */ new Set([
   "logger",
   "log",
   "logging",
@@ -2535,12 +3136,12 @@ function isSecretKeyword(name) {
 function isLoggerExpr(expr) {
   switch (expr.type) {
     case "Identifier":
-      return LOGGER_NAMES.has(expr.name.toLowerCase());
+      return LOGGER_NAMES2.has(expr.name.toLowerCase());
     case "MemberExpression": {
       const { property, object } = expr;
       if (!expr.computed && property.type === "Identifier") {
         const lowered = property.name.toLowerCase();
-        if (LOGGER_NAMES.has(lowered) || LOGGER_FACTORIES.has(lowered)) {
+        if (LOGGER_NAMES2.has(lowered) || LOGGER_FACTORIES.has(lowered)) {
           return true;
         }
       }
@@ -2578,7 +3179,7 @@ function propertyKeyName2(prop) {
   }
   return null;
 }
-var no_secret_in_log_default = import_utils24.ESLintUtils.RuleCreator(
+var no_secret_in_log_default = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-secret-in-log",
@@ -2597,7 +3198,7 @@ var no_secret_in_log_default = import_utils24.ESLintUtils.RuleCreator(
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier" || !LOG_METHODS.has(callee.property.name)) {
+        if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier" || !LOG_METHODS2.has(callee.property.name)) {
           return;
         }
         if (!isLoggerExpr(callee.object)) {
@@ -2614,6 +3215,16 @@ var no_secret_in_log_default = import_utils24.ESLintUtils.RuleCreator(
             }
             continue;
           }
+          if (arg.type === "MemberExpression") {
+            if (!arg.computed && arg.property.type === "Identifier" && isSecretKeyword(arg.property.name)) {
+              context.report({
+                node: arg,
+                messageId: "noSecretInLog",
+                data: { name: arg.property.name }
+              });
+            }
+            continue;
+          }
           if (arg.type === "ObjectExpression") {
             for (const prop of arg.properties) {
               if (prop.type !== "Property") {
@@ -2636,7 +3247,7 @@ var no_secret_in_log_default = import_utils24.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -2679,19 +3290,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils25.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils26.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils25.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils26.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils25.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils25.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils26.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils26.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils25.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils26.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -2720,12 +3331,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils25.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils26.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils25.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils26.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils25.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils26.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -2733,12 +3344,12 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils25.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils26.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
 }
-var prefer_string_literal_union_default = import_utils25.ESLintUtils.RuleCreator(
+var prefer_string_literal_union_default = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-string-literal-union",
@@ -2762,7 +3373,7 @@ var prefer_string_literal_union_default = import_utils25.ESLintUtils.RuleCreator
     }
     let services;
     try {
-      services = import_utils25.ESLintUtils.getParserServices(context);
+      services = import_utils26.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -2846,7 +3457,7 @@ var prefer_string_literal_union_default = import_utils25.ESLintUtils.RuleCreator
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils25.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils26.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -2934,10 +3545,10 @@ var prefer_string_literal_union_default = import_utils25.ESLintUtils.RuleCreator
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils25.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils26.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils25.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils26.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -2946,7 +3557,7 @@ var prefer_string_literal_union_default = import_utils25.ESLintUtils.RuleCreator
 });
 
 // src/rules/single-public-export.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var JUNK_DRAWER_STEMS = /* @__PURE__ */ new Set([
   "util",
   "utils",
@@ -2973,20 +3584,20 @@ var TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
 var SCRIPT_EXT_RE = /\.[cm]?[jt]sx?$/i;
 var basename = (filename) => filename.split(/[/\\]/).pop() ?? filename;
 var stemOf = (base) => base.replace(SCRIPT_EXT_RE, "");
-var kebabCase = (name) => {
+var kebabCase2 = (name) => {
   let normalized = name;
   for (const [pattern, replacement] of ACRONYM_OVERRIDES) {
     normalized = normalized.replace(pattern, replacement);
   }
   return normalized.replace(CAMEL_BOUNDARY_RE, "-").toLowerCase();
 };
-var isFunctionExpression2 = (node) => node !== null && (node.type === import_utils26.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils26.AST_NODE_TYPES.FunctionExpression);
+var isFunctionExpression = (node) => node !== null && (node.type === import_utils27.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils27.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_utils26.AST_NODE_TYPES.Identifier) return null;
-  if (!isFunctionExpression2(declarator.init)) return null;
+  if (declarator.id.type !== import_utils27.AST_NODE_TYPES.Identifier) return null;
+  if (!isFunctionExpression(declarator.init)) return null;
   return declarator.id.name;
 };
 var summarizeExports = (body) => {
@@ -2999,20 +3610,20 @@ var summarizeExports = (body) => {
   };
   for (const statement of body) {
     switch (statement.type) {
-      case import_utils26.AST_NODE_TYPES.ExportAllDeclaration:
+      case import_utils27.AST_NODE_TYPES.ExportAllDeclaration:
         hasReExport = true;
         break;
-      case import_utils26.AST_NODE_TYPES.ExportDefaultDeclaration: {
+      case import_utils27.AST_NODE_TYPES.ExportDefaultDeclaration: {
         names += 1;
         const decl = statement.declaration;
-        if (decl.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
+        if (decl.type === import_utils27.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
-        } else if (decl.type === import_utils26.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
+        } else if (decl.type === import_utils27.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
         }
         break;
       }
-      case import_utils26.AST_NODE_TYPES.ExportNamedDeclaration: {
+      case import_utils27.AST_NODE_TYPES.ExportNamedDeclaration: {
         if (statement.source !== null) {
           hasReExport = true;
           break;
@@ -3023,15 +3634,15 @@ var summarizeExports = (body) => {
           break;
         }
         switch (decl.type) {
-          case import_utils26.AST_NODE_TYPES.FunctionDeclaration:
+          case import_utils27.AST_NODE_TYPES.FunctionDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils26.AST_NODE_TYPES.ClassDeclaration:
+          case import_utils27.AST_NODE_TYPES.ClassDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils26.AST_NODE_TYPES.VariableDeclaration: {
+          case import_utils27.AST_NODE_TYPES.VariableDeclaration: {
             const fnName = functionConstName(decl);
             if (fnName !== null && decl.declarations.length === 1) {
               addCandidate(fnName, statement);
@@ -3051,7 +3662,7 @@ var summarizeExports = (body) => {
   }
   return { names, hasReExport, candidate };
 };
-var single_public_export_default = import_utils26.ESLintUtils.RuleCreator(
+var single_public_export_default = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "single-public-export",
@@ -3078,7 +3689,7 @@ var single_public_export_default = import_utils26.ESLintUtils.RuleCreator(
         if (hasReExport) return;
         if (names !== 1 || candidate === null) return;
         if (CONVENTIONAL_BUCKET_EXPORTS.has(candidate.name)) return;
-        const expected = kebabCase(candidate.name);
+        const expected = kebabCase2(candidate.name);
         if (stem === expected) return;
         context.report({
           node: candidate.node,
@@ -3121,7 +3732,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.3.4"
+    version: "2.4.1"
   },
   rules,
   configs: {