@sarj/eslint-plugin 2.3.4 → 2.4.1

package/dist/index.js

@@ -1,42 +1,19 @@
 // src/rules/enforce-file-structure.ts
 import { ESLintUtils, AST_NODE_TYPES } from "@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 === AST_NODE_TYPES.ArrowFunctionExpression || node.type === 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 AST_NODE_TYPES.ImportDeclaration:
-    case AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case AST_NODE_TYPES.TSInterfaceDeclaration:
-    case AST_NODE_TYPES.TSEnumDeclaration:
-    case AST_NODE_TYPES.ClassDeclaration:
-      return SECTION.declarations;
-    case AST_NODE_TYPES.VariableDeclaration:
-      return isFunctionLikeVariable(statement) ? SECTION.functions : SECTION.declarations;
-    case AST_NODE_TYPES.FunctionDeclaration:
-      return SECTION.functions;
-    case AST_NODE_TYPES.ExportNamedDeclaration:
-    case AST_NODE_TYPES.ExportDefaultDeclaration:
+      return "import";
     case AST_NODE_TYPES.ExportAllDeclaration:
-      return SECTION.exports;
+      return "reexport";
+    case AST_NODE_TYPES.ExportNamedDeclaration:
+      return statement.declaration === null ? "reexport" : "body";
     default:
-      return SECTION.functions;
+      return "body";
   }
 };
+var isStringDirective = (statement) => statement.type === AST_NODE_TYPES.ExpressionStatement && statement.expression.type === 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 !== AST_NODE_TYPES.ExpressionStatement) return false;
   const expr = statement.expression;
   if (expr.type !== AST_NODE_TYPES.Literal) return false;
@@ -49,47 +26,45 @@ var enforce_file_structure_default = 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 === AST_NODE_TYPES.ExpressionStatement && statement.expression.type === 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;
           }
         }
       }
@@ -238,7 +213,7 @@ var no_client_side_data_fetching_default = ESLintUtils2.RuleCreator(
 // src/rules/no-comment-cruft.ts
 import { ESLintUtils as ESLintUtils3 } from "@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,}/;
@@ -246,8 +221,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());
@@ -263,6 +239,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 = ESLintUtils3.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -317,12 +317,19 @@ var no_comment_cruft_default = ESLintUtils3.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" });
           }
         }
@@ -404,7 +411,9 @@ var no_enum_default = ESLintUtils4.RuleCreator(
 
 // src/rules/no-insecure-random-id.ts
 import { ESLintUtils as ESLintUtils5 } from "@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;
@@ -416,6 +425,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;
@@ -481,6 +508,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 = ESLintUtils5.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -502,12 +572,18 @@ var no_insecure_random_id_default = ESLintUtils5.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" });
         }
       }
@@ -518,6 +594,8 @@ var no_insecure_random_id_default = ESLintUtils5.RuleCreator(
 // src/rules/no-json-stringify-error.ts
 import { ESLintUtils as ESLintUtils6 } from "@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) {
@@ -533,6 +611,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";
 }
@@ -558,17 +728,28 @@ var no_json_stringify_error_default = ESLintUtils6.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"
+        });
       }
     };
   }
@@ -576,41 +757,81 @@ var no_json_stringify_error_default = ESLintUtils6.RuleCreator(
 
 // src/rules/no-log-only-catch.ts
 import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
-var DEFAULT_IGNORE_PATTERNS2 = [
-  /\.test\./,
-  /\.spec\./,
-  /[\\/]__tests__[\\/]/
-];
-var CONSOLE_METHODS = /* @__PURE__ */ new Set([
-  "log",
-  "error",
-  "warn",
+
+// src/rules/_logging.ts
+import "@typescript-eslint/utils";
+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 = ESLintUtils7.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
@@ -619,11 +840,12 @@ var no_log_only_catch_default = ESLintUtils7.RuleCreator(
   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: [],
@@ -639,13 +861,16 @@ var no_log_only_catch_default = ESLintUtils7.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" });
         }
       }
@@ -655,6 +880,23 @@ var no_log_only_catch_default = ESLintUtils7.RuleCreator(
 
 // src/rules/no-raw-env.ts
 import { ESLintUtils as ESLintUtils8 } from "@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 = ESLintUtils8.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -673,10 +915,7 @@ var no_raw_env_default = ESLintUtils8.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"
@@ -692,6 +931,33 @@ import {
   ESLintUtils as ESLintUtils9,
   AST_NODE_TYPES as AST_NODE_TYPES3
 } from "@typescript-eslint/utils";
+function sentinelKind(arg) {
+  if (arg === null) {
+    return null;
+  }
+  if (arg.type === AST_NODE_TYPES3.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 === AST_NODE_TYPES3.Identifier && arg.name === "undefined") {
+    return "nullish";
+  }
+  if (arg.type === AST_NODE_TYPES3.ArrayExpression) {
+    return "array";
+  }
+  if (arg.type === AST_NODE_TYPES3.ObjectExpression) {
+    return "object";
+  }
+  return null;
+}
 function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
@@ -713,17 +979,23 @@ function isSentinelArgument(arg) {
   }
   return false;
 }
-function containsThrow(node) {
+function isFunctionNode(node) {
+  return node.type === AST_NODE_TYPES3.FunctionDeclaration || node.type === AST_NODE_TYPES3.FunctionExpression || node.type === AST_NODE_TYPES3.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 === AST_NODE_TYPES3.ThrowStatement) {
+    if (visit(current)) {
       found = true;
       return;
     }
-    if (current.type === AST_NODE_TYPES3.FunctionDeclaration || current.type === AST_NODE_TYPES3.FunctionExpression || current.type === AST_NODE_TYPES3.ArrowFunctionExpression) {
+    if (isFunctionNode(current)) {
       return;
     }
     for (const key of Object.keys(current)) {
@@ -734,19 +1006,98 @@ 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 === AST_NODE_TYPES3.ThrowStatement
+  );
+}
+function argsIncludeBinding(args, caughtName) {
+  if (caughtName === null) {
+    return false;
+  }
+  return args.some(
+    (arg) => arg.type === AST_NODE_TYPES3.Identifier && arg.name === caughtName
+  );
+}
+function logsOrReportsError(catchBody, caughtName) {
+  return walkWithinScope(catchBody, (current) => {
+    if (current.type !== AST_NODE_TYPES3.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 === AST_NODE_TYPES3.CallExpression && arg.callee.type === AST_NODE_TYPES3.MemberExpression && !arg.callee.computed && arg.callee.property.type === AST_NODE_TYPES3.Identifier && arg.callee.property.name === "parse") {
+    return true;
+  }
+  if (arg.type === AST_NODE_TYPES3.NewExpression && arg.callee.type === AST_NODE_TYPES3.Identifier) {
+    return arg.callee.name === "RegExp" || arg.callee.name === "URL";
+  }
+  return false;
+}
+function tryReturnsSafeParse(catchNode) {
+  return walkWithinScope(
+    tryBlockOf(catchNode),
+    (current) => current.type === AST_NODE_TYPES3.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 === AST_NODE_TYPES3.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 !== AST_NODE_TYPES3.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 = ESLintUtils9.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
@@ -755,11 +1106,11 @@ var no_sentinel_return_on_catch_default = ESLintUtils9.RuleCreator(
   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: [],
@@ -780,6 +1131,17 @@ var no_sentinel_return_on_catch_default = ESLintUtils9.RuleCreator(
         if (containsThrow(node.body)) {
           return;
         }
+        const caughtName = node.param?.type === AST_NODE_TYPES3.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"
@@ -791,12 +1153,110 @@ var no_sentinel_return_on_catch_default = ESLintUtils9.RuleCreator(
 
 // src/rules/no-sequential-await.ts
 import { ESLintUtils as ESLintUtils10 } from "@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";
 }
+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 = ESLintUtils10.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -813,54 +1273,36 @@ var no_sequential_await_default = ESLintUtils10.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 {
       ForStatement: checkLoop,
@@ -872,6 +1314,28 @@ var no_sequential_await_default = ESLintUtils10.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" });
+        }
       }
     };
   }
@@ -923,6 +1387,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;
@@ -956,10 +1435,11 @@ var no_string_concat_in_loop_default = ESLintUtils11.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)) {
@@ -1262,6 +1742,30 @@ 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 AST_NODE_TYPES6.UnaryExpression:
+      case AST_NODE_TYPES6.LogicalExpression:
+      case AST_NODE_TYPES6.ChainExpression:
+        current = parent;
+        parent = parent.parent;
+        continue;
+      case AST_NODE_TYPES6.IfStatement:
+      case AST_NODE_TYPES6.ConditionalExpression:
+      case AST_NODE_TYPES6.WhileStatement:
+      case AST_NODE_TYPES6.DoWhileStatement:
+      case AST_NODE_TYPES6.ForStatement:
+        return parent.test === current;
+      default:
+        return false;
+    }
+  }
+  return false;
+};
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
   if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES6.Identifier) {
@@ -1340,6 +1844,22 @@ var prefer_schema_for_api_payload_default = ESLintUtils14.RuleCreator(
           }
         }
       },
+      CallExpression(node) {
+        if (node.callee.type !== AST_NODE_TYPES6.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 === AST_NODE_TYPES6.SpreadElement) continue;
+          const unwrapped = unwrap(arg);
+          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES6.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);
@@ -1401,6 +1921,35 @@ 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 === AST_NODE_TYPES7.JSXElement && current.openingElement.name.type === AST_NODE_TYPES7.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 === AST_NODE_TYPES7.Identifier) return key.name;
   if (key.type === AST_NODE_TYPES7.Literal && typeof key.value === "string") return key.value;
@@ -1424,6 +1973,7 @@ var prefer_semantic_colors_default = ESLintUtils15.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);
@@ -1495,9 +2045,16 @@ var prefer_semantic_colors_default = ESLintUtils15.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 === AST_NODE_TYPES7.Literal) checkColorValueNode(node.value);
+        if (node.value?.type !== AST_NODE_TYPES7.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) {
@@ -1656,13 +2213,40 @@ var prefer_server_actions_default = ESLintUtils16.RuleCreator(
 });
 
 // src/rules/prefer-shadcn.ts
-import { ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES8,
+  ESLintUtils as ESLintUtils17
+} from "@typescript-eslint/utils";
 var REPLACEMENTS = {
-  input: "Input",
   select: "Select",
   textarea: "Textarea",
   dialog: "Dialog"
 };
+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 !== AST_NODE_TYPES8.JSXAttribute || attribute.name.type !== AST_NODE_TYPES8.JSXIdentifier || attribute.name.name !== "type") {
+      continue;
+    }
+    if (attribute.value?.type === AST_NODE_TYPES8.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 = ESLintUtils17.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -1685,8 +2269,8 @@ var prefer_shadcn_default = ESLintUtils17.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({
@@ -1695,7 +2279,7 @@ var prefer_shadcn_default = ESLintUtils17.RuleCreator(
           data: {
             element: elementName,
             replacement,
-            lowercase: elementName
+            lowercase: kebabCase(replacement)
           }
         });
       }
@@ -1704,40 +2288,59 @@ var prefer_shadcn_default = ESLintUtils17.RuleCreator(
 });
 
 // src/rules/require-assert-never.ts
-import { ESLintUtils as ESLintUtils18, AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import {
+  ESLintUtils as ESLintUtils18,
+  AST_NODE_TYPES as AST_NODE_TYPES9
+} from "@typescript-eslint/utils";
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== AST_NODE_TYPES8.CallExpression) return false;
+  if (expression.type !== AST_NODE_TYPES9.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === AST_NODE_TYPES8.Identifier) {
+  if (callee.type === AST_NODE_TYPES9.Identifier) {
     return callee.name === "assertNever";
   }
-  if (callee.type === AST_NODE_TYPES8.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES8.Identifier) {
+  if (callee.type === AST_NODE_TYPES9.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES9.Identifier) {
     return callee.property.name === "assertNever";
   }
   return false;
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === AST_NODE_TYPES8.ExpressionStatement) {
+  if (statement.type === AST_NODE_TYPES9.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === AST_NODE_TYPES8.ThrowStatement) {
+  if (statement.type === AST_NODE_TYPES9.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === AST_NODE_TYPES8.ReturnStatement) {
+  if (statement.type === AST_NODE_TYPES9.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === AST_NODE_TYPES8.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES9.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === AST_NODE_TYPES8.EmptyStatement) return false;
-  if (statement.type === AST_NODE_TYPES8.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES9.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES9.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
 };
+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 === AST_NODE_TYPES9.BlockStatement && only.body.length === 0) {
+    return sourceCode.getCommentsInside(only).length > 0;
+  }
+  return false;
+};
 var require_assert_never_default = ESLintUtils18.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
@@ -1756,12 +2359,16 @@ var require_assert_never_default = ESLintUtils18.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"
@@ -1772,19 +2379,19 @@ var require_assert_never_default = ESLintUtils18.RuleCreator(
 });
 
 // src/rules/require-zod-form-validation.ts
-import { ESLintUtils as ESLintUtils19, AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils19, AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
 var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES9.Identifier) {
+    if (current.type === AST_NODE_TYPES10.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === AST_NODE_TYPES9.CallExpression) {
+    if (current.type === AST_NODE_TYPES10.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES9.MemberExpression) {
+    if (current.type === AST_NODE_TYPES10.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -1792,23 +2399,23 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== AST_NODE_TYPES9.CallExpression) return false;
+  if (node.type !== AST_NODE_TYPES10.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES9.MemberExpression) return false;
+  if (callee.type !== AST_NODE_TYPES10.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== AST_NODE_TYPES9.Identifier) return false;
+  if (callee.property.type !== AST_NODE_TYPES10.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 === AST_NODE_TYPES9.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES10.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES9.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES10.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES9.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES9.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES10.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES10.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = ESLintUtils19.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
@@ -1827,14 +2434,14 @@ var require_zod_form_validation_default = ESLintUtils19.RuleCreator(
   defaultOptions: [],
   create(context) {
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== AST_NODE_TYPES9.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES10.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 === AST_NODE_TYPES9.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES10.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -1845,8 +2452,8 @@ var require_zod_form_validation_default = ESLintUtils19.RuleCreator(
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES9.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES9.Identifier || callee.property.name !== "get") {
+      if (callee.type !== AST_NODE_TYPES10.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES10.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -1869,15 +2476,15 @@ var require_zod_form_validation_default = ESLintUtils19.RuleCreator(
 });
 
 // src/rules/zod-naming-convention.ts
-import { ESLintUtils as ESLintUtils20, AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils20, AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === AST_NODE_TYPES10.MemberExpression) {
+  while (current.type === AST_NODE_TYPES11.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === AST_NODE_TYPES10.Identifier && receiver.name === "z") {
+    if (receiver.type === AST_NODE_TYPES11.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === AST_NODE_TYPES10.CallExpression) {
+    if (receiver.type === AST_NODE_TYPES11.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -1905,11 +2512,11 @@ var zod_naming_convention_default = ESLintUtils20.RuleCreator(
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== AST_NODE_TYPES10.CallExpression) return;
+        if (init.type !== AST_NODE_TYPES11.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== AST_NODE_TYPES10.MemberExpression) return;
+        if (callee.type !== AST_NODE_TYPES11.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
-        if (node.id.type !== AST_NODE_TYPES10.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES11.Identifier) return;
         const variableName = node.id.name;
         if (variableName.startsWith("Z")) return;
         context.report({
@@ -1954,17 +2561,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) {
@@ -1980,7 +2587,7 @@ function propertyKeyName(prop) {
   }
   return void 0;
 }
-function calleeName(node) {
+function calleeName3(node) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
     return callee.name;
@@ -1991,7 +2598,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;
   }
@@ -2134,13 +2741,13 @@ var no_cors_wildcard_with_credentials_default = ESLintUtils21.RuleCreator(
 // src/rules/no-fat-try-blocks.ts
 import {
   ESLintUtils as ESLintUtils22,
-  AST_NODE_TYPES as AST_NODE_TYPES11
+  AST_NODE_TYPES as AST_NODE_TYPES12
 } from "@typescript-eslint/utils";
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES11.FunctionDeclaration,
-  AST_NODE_TYPES11.FunctionExpression,
-  AST_NODE_TYPES11.ArrowFunctionExpression
+  AST_NODE_TYPES12.FunctionDeclaration,
+  AST_NODE_TYPES12.FunctionExpression,
+  AST_NODE_TYPES12.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -2233,25 +2840,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 !== AST_NODE_TYPES11.MemberExpression) {
+  if (callee.type !== AST_NODE_TYPES12.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== AST_NODE_TYPES11.Identifier) {
+  if (property.type !== AST_NODE_TYPES12.Identifier) {
     return false;
   }
-  if (callee.object.type === AST_NODE_TYPES11.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === AST_NODE_TYPES12.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
     return true;
   }
   return PURE_METHODS.has(property.name);
 }
 function isPureNew(node) {
-  return node.callee.type === AST_NODE_TYPES11.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === AST_NODE_TYPES12.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
 function subtreeMatches(stmt, predicate) {
   let found = false;
@@ -2273,11 +2880,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) {
@@ -2288,14 +2895,14 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === AST_NODE_TYPES11.AwaitExpression);
+var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === AST_NODE_TYPES12.AwaitExpression);
 var hasThrowingCallOrNew = (stmt) => subtreeMatches(
   stmt,
-  (n) => n.type === AST_NODE_TYPES11.CallExpression && !isPureCall(n) || n.type === AST_NODE_TYPES11.NewExpression && !isPureNew(n)
+  (n) => n.type === AST_NODE_TYPES12.CallExpression && !isPureCall(n) || n.type === AST_NODE_TYPES12.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === AST_NODE_TYPES11.ChainExpression || current.type === AST_NODE_TYPES11.TSNonNullExpression) {
+  while (current.type === AST_NODE_TYPES12.ChainExpression || current.type === AST_NODE_TYPES12.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
@@ -2304,7 +2911,7 @@ function canThrow(stmt) {
   if (hasAwait(stmt)) {
     return true;
   }
-  if (stmt.type === AST_NODE_TYPES11.ExpressionStatement && unwrap2(stmt.expression).type === AST_NODE_TYPES11.CallExpression) {
+  if (stmt.type === AST_NODE_TYPES12.ExpressionStatement && unwrap2(stmt.expression).type === AST_NODE_TYPES12.CallExpression) {
     return false;
   }
   return hasThrowingCallOrNew(stmt);
@@ -2315,7 +2922,7 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === AST_NODE_TYPES11.ThrowStatement;
+  return last !== void 0 && last.type === AST_NODE_TYPES12.ThrowStatement;
 }
 var no_fat_try_blocks_default = ESLintUtils22.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
@@ -2359,7 +2966,7 @@ var no_fat_try_blocks_default = ESLintUtils22.RuleCreator(
 
 // src/rules/no-secret-in-log.ts
 import { ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
-var LOG_METHODS = /* @__PURE__ */ new Set([
+var LOG_METHODS2 = /* @__PURE__ */ new Set([
   "debug",
   "info",
   "warn",
@@ -2372,7 +2979,7 @@ var LOG_METHODS = /* @__PURE__ */ new Set([
   "fatal",
   "success"
 ]);
-var LOGGER_NAMES = /* @__PURE__ */ new Set([
+var LOGGER_NAMES2 = /* @__PURE__ */ new Set([
   "logger",
   "log",
   "logging",
@@ -2513,12 +3120,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;
         }
       }
@@ -2575,7 +3182,7 @@ var no_secret_in_log_default = ESLintUtils23.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)) {
@@ -2592,6 +3199,16 @@ var no_secret_in_log_default = ESLintUtils23.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") {
@@ -2616,7 +3233,7 @@ var no_secret_in_log_default = ESLintUtils23.RuleCreator(
 // src/rules/prefer-string-literal-union.ts
 import {
   ESLintUtils as ESLintUtils24,
-  AST_NODE_TYPES as AST_NODE_TYPES12
+  AST_NODE_TYPES as AST_NODE_TYPES13
 } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
@@ -2660,19 +3277,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === AST_NODE_TYPES12.Identifier) {
+  if (key.type === AST_NODE_TYPES13.Identifier) {
     return key.name;
   }
-  if (key.type === AST_NODE_TYPES12.Literal && typeof key.value === "string") {
+  if (key.type === AST_NODE_TYPES13.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === AST_NODE_TYPES12.TSLiteralType && t.literal.type === AST_NODE_TYPES12.Literal && typeof t.literal.value === "string";
+  return t.type === AST_NODE_TYPES13.TSLiteralType && t.literal.type === AST_NODE_TYPES13.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== AST_NODE_TYPES12.TSUnionType) {
+  if (node?.type !== AST_NODE_TYPES13.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -2701,12 +3318,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === AST_NODE_TYPES12.Identifier) {
+  if (node.type === AST_NODE_TYPES13.Identifier) {
     return node.name;
   }
-  if (node.type === AST_NODE_TYPES12.MemberExpression && !node.computed) {
+  if (node.type === AST_NODE_TYPES13.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== AST_NODE_TYPES12.Identifier) {
+    if (inner === null || node.property.type !== AST_NODE_TYPES13.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -2714,7 +3331,7 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === AST_NODE_TYPES12.Literal && typeof node.value === "string") {
+  if (node.type === AST_NODE_TYPES13.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
@@ -2827,7 +3444,7 @@ var prefer_string_literal_union_default = ESLintUtils24.RuleCreator(
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== AST_NODE_TYPES12.TSStringKeyword) {
+      if (typeNode?.type !== AST_NODE_TYPES13.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -2915,10 +3532,10 @@ var prefer_string_literal_union_default = ESLintUtils24.RuleCreator(
       }
     };
     function refKeyText(node) {
-      if (node.type === AST_NODE_TYPES12.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES13.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === AST_NODE_TYPES12.SwitchStatement) {
+      if (node.type === AST_NODE_TYPES13.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -2927,7 +3544,7 @@ var prefer_string_literal_union_default = ESLintUtils24.RuleCreator(
 });
 
 // src/rules/single-public-export.ts
-import { ESLintUtils as ESLintUtils25, AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils25, AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
 var JUNK_DRAWER_STEMS = /* @__PURE__ */ new Set([
   "util",
   "utils",
@@ -2954,20 +3571,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 === AST_NODE_TYPES13.ArrowFunctionExpression || node.type === AST_NODE_TYPES13.FunctionExpression);
+var isFunctionExpression = (node) => node !== null && (node.type === AST_NODE_TYPES14.ArrowFunctionExpression || node.type === AST_NODE_TYPES14.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 !== AST_NODE_TYPES13.Identifier) return null;
-  if (!isFunctionExpression2(declarator.init)) return null;
+  if (declarator.id.type !== AST_NODE_TYPES14.Identifier) return null;
+  if (!isFunctionExpression(declarator.init)) return null;
   return declarator.id.name;
 };
 var summarizeExports = (body) => {
@@ -2980,20 +3597,20 @@ var summarizeExports = (body) => {
   };
   for (const statement of body) {
     switch (statement.type) {
-      case AST_NODE_TYPES13.ExportAllDeclaration:
+      case AST_NODE_TYPES14.ExportAllDeclaration:
         hasReExport = true;
         break;
-      case AST_NODE_TYPES13.ExportDefaultDeclaration: {
+      case AST_NODE_TYPES14.ExportDefaultDeclaration: {
         names += 1;
         const decl = statement.declaration;
-        if (decl.type === AST_NODE_TYPES13.FunctionDeclaration && decl.id !== null) {
+        if (decl.type === AST_NODE_TYPES14.FunctionDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
-        } else if (decl.type === AST_NODE_TYPES13.ClassDeclaration && decl.id !== null) {
+        } else if (decl.type === AST_NODE_TYPES14.ClassDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
         }
         break;
       }
-      case AST_NODE_TYPES13.ExportNamedDeclaration: {
+      case AST_NODE_TYPES14.ExportNamedDeclaration: {
         if (statement.source !== null) {
           hasReExport = true;
           break;
@@ -3004,15 +3621,15 @@ var summarizeExports = (body) => {
           break;
         }
         switch (decl.type) {
-          case AST_NODE_TYPES13.FunctionDeclaration:
+          case AST_NODE_TYPES14.FunctionDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case AST_NODE_TYPES13.ClassDeclaration:
+          case AST_NODE_TYPES14.ClassDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case AST_NODE_TYPES13.VariableDeclaration: {
+          case AST_NODE_TYPES14.VariableDeclaration: {
             const fnName = functionConstName(decl);
             if (fnName !== null && decl.declarations.length === 1) {
               addCandidate(fnName, statement);
@@ -3059,7 +3676,7 @@ var single_public_export_default = ESLintUtils25.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,
@@ -3102,7 +3719,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.3.4"
+    version: "2.4.1"
   },
   rules,
   configs: {