@sarj/eslint-plugin 2.0.2 → 2.1.1

package/dist/index.cjs

@@ -345,9 +345,260 @@ var no_enum_default = import_utils3.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/no-raw-env.ts
+// src/rules/no-insecure-random-id.ts
 var import_utils4 = require("@typescript-eslint/utils");
-var no_raw_env_default = import_utils4.ESLintUtils.RuleCreator(
+var NAME_PATTERN = /id|token|key|secret|uuid|nonce|session|password|salt/i;
+function isMathRandomCall(node) {
+  if (node.type !== "CallExpression") {
+    return false;
+  }
+  const callee = node.callee;
+  if (callee.type !== "MemberExpression" || callee.computed) {
+    return false;
+  }
+  const { object, property } = callee;
+  return object.type === "Identifier" && object.name === "Math" && property.type === "Identifier" && property.name === "random";
+}
+function isPartOfToString36Chain(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent) {
+    if (parent.type === "MemberExpression" && parent.object === current && !parent.computed && parent.property.type === "Identifier" && parent.property.name === "toString") {
+      const grandparent = parent.parent;
+      if (grandparent && grandparent.type === "CallExpression" && grandparent.callee === parent) {
+        const firstArg = grandparent.arguments[0];
+        if (firstArg && firstArg.type === "Literal" && firstArg.value === 36) {
+          return true;
+        }
+      }
+    }
+    if (parent.type === "MemberExpression" && parent.object === current) {
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    if (parent.type === "CallExpression" && parent.callee === current) {
+      current = parent;
+      parent = current.parent;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+function findEnclosingName(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent) {
+    if (parent.type === "VariableDeclarator" && parent.init === current) {
+      if (parent.id.type === "Identifier") {
+        return parent.id.name;
+      }
+      return void 0;
+    }
+    if (parent.type === "Property" && parent.value === current) {
+      const key = parent.key;
+      if (!parent.computed && key.type === "Identifier") {
+        return key.name;
+      }
+      if (key.type === "Literal" && typeof key.value === "string") {
+        return key.value;
+      }
+      return void 0;
+    }
+    if (parent.type === "PropertyDefinition" && parent.value === current) {
+      const key = parent.key;
+      if (!parent.computed && key.type === "Identifier") {
+        return key.name;
+      }
+      if (key.type === "Literal" && typeof key.value === "string") {
+        return key.value;
+      }
+      return void 0;
+    }
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression" || parent.type === "BlockStatement" || parent.type === "ReturnStatement" || parent.type === "ExpressionStatement") {
+      return void 0;
+    }
+    current = parent;
+    parent = current.parent;
+  }
+  return void 0;
+}
+var no_insecure_random_id_default = import_utils4.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-insecure-random-id",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow using `Math.random()` to generate identifiers, tokens, or secrets; use `crypto.randomUUID()` or `crypto.getRandomValues(...)` instead."
+    },
+    schema: [],
+    messages: {
+      insecureRandomId: "`Math.random()` is not cryptographically secure and is predictable; do not use it to generate IDs, tokens, or secrets. Use `crypto.randomUUID()` or `crypto.getRandomValues(...)` instead."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isMathRandomCall(node)) {
+          return;
+        }
+        if (isPartOfToString36Chain(node)) {
+          context.report({ node, messageId: "insecureRandomId" });
+          return;
+        }
+        const name = findEnclosingName(node);
+        if (name !== void 0 && NAME_PATTERN.test(name)) {
+          context.report({ node, messageId: "insecureRandomId" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-json-stringify-error.ts
+var import_utils5 = require("@typescript-eslint/utils");
+var ERROR_NAME_PATTERN = /^(e|err|error|ex|exc)$/i;
+function isCatchBinding(scope, name) {
+  let current = scope;
+  while (current) {
+    const variable = current.set.get(name);
+    if (variable) {
+      for (const def of variable.defs) {
+        if (def.type === "CatchClause") {
+          return true;
+        }
+      }
+    }
+    current = current.upper;
+  }
+  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";
+}
+var no_json_stringify_error_default = import_utils5.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-json-stringify-error",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `JSON.stringify` on an Error value; it yields `{}` because `message`/`stack` are non-enumerable."
+    },
+    schema: [],
+    messages: {
+      noJsonStringifyError: "`JSON.stringify` on an Error yields `{}` because `message`/`stack` are non-enumerable. Log `err.message` / `err.stack`, or use a proper error serializer."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isJsonStringify(node.callee)) {
+          return;
+        }
+        const firstArg = node.arguments[0];
+        if (!firstArg || firstArg.type !== "Identifier") {
+          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"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-log-only-catch.ts
+var import_utils6 = require("@typescript-eslint/utils");
+var DEFAULT_IGNORE_PATTERNS2 = [
+  /\.test\./,
+  /\.spec\./,
+  /[\\/]__tests__[\\/]/
+];
+var CONSOLE_METHODS = /* @__PURE__ */ new Set([
+  "log",
+  "error",
+  "warn",
+  "info",
+  "debug"
+]);
+function isConsoleCallStatement(statement) {
+  if (statement.type !== "ExpressionStatement") {
+    return false;
+  }
+  const expr = statement.expression;
+  if (expr.type !== "CallExpression") {
+    return false;
+  }
+  const callee = expr.callee;
+  if (callee.type !== "MemberExpression") {
+    return false;
+  }
+  const { object, property } = callee;
+  if (object.type !== "Identifier" || object.name !== "console") {
+    return false;
+  }
+  if (callee.computed) {
+    return false;
+  }
+  if (property.type !== "Identifier") {
+    return false;
+  }
+  return CONSOLE_METHODS.has(property.name);
+}
+var no_log_only_catch_default = import_utils6.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."
+    },
+    schema: [],
+    messages: {
+      noLogOnlyCatch: "Logging then swallowing the error hides failures. Rethrow the error or handle it for real."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename;
+    const isIgnoredByDefault = DEFAULT_IGNORE_PATTERNS2.some(
+      (re) => re.test(filename)
+    );
+    if (isIgnoredByDefault) {
+      return {};
+    }
+    return {
+      CatchClause(node) {
+        const statements = node.body.body;
+        if (statements.length === 0) {
+          context.report({ node, messageId: "noLogOnlyCatch" });
+          return;
+        }
+        const everyStatementIsConsoleLog = statements.every(
+          (statement) => isConsoleCallStatement(statement)
+        );
+        if (everyStatementIsConsoleLog) {
+          context.report({ node, messageId: "noLogOnlyCatch" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-raw-env.ts
+var import_utils7 = require("@typescript-eslint/utils");
+var no_raw_env_default = import_utils7.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-env",
@@ -379,8 +630,300 @@ var no_raw_env_default = import_utils4.ESLintUtils.RuleCreator(
   }
 });
 
+// src/rules/no-sentinel-return-on-catch.ts
+var import_utils8 = require("@typescript-eslint/utils");
+function isSentinelArgument(arg) {
+  if (arg === null) {
+    return false;
+  }
+  if (arg.type === import_utils8.AST_NODE_TYPES.Literal && arg.value === null) {
+    return true;
+  }
+  if (arg.type === import_utils8.AST_NODE_TYPES.Literal && arg.value === false) {
+    return true;
+  }
+  if (arg.type === import_utils8.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+    return true;
+  }
+  if (arg.type === import_utils8.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
+    return true;
+  }
+  if (arg.type === import_utils8.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
+    return true;
+  }
+  return false;
+}
+function containsThrow(node) {
+  let found = false;
+  const visit = (current) => {
+    if (found) {
+      return;
+    }
+    if (current.type === import_utils8.AST_NODE_TYPES.ThrowStatement) {
+      found = true;
+      return;
+    }
+    if (current.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils8.AST_NODE_TYPES.FunctionExpression || current.type === import_utils8.AST_NODE_TYPES.ArrowFunctionExpression) {
+      return;
+    }
+    for (const key of Object.keys(current)) {
+      if (key === "parent") {
+        continue;
+      }
+      const value = current[key];
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (isNode(child)) {
+            visit(child);
+          }
+        }
+      } else if (isNode(value)) {
+        visit(value);
+      }
+    }
+  };
+  visit(node);
+  return found;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+var no_sentinel_return_on_catch_default = import_utils8.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."
+    },
+    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."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CatchClause(node) {
+        const body = node.body.body;
+        if (body.length === 0) {
+          return;
+        }
+        const last = body[body.length - 1];
+        if (last === void 0 || last.type !== import_utils8.AST_NODE_TYPES.ReturnStatement) {
+          return;
+        }
+        if (!isSentinelArgument(last.argument)) {
+          return;
+        }
+        if (containsThrow(node.body)) {
+          return;
+        }
+        context.report({
+          node: last,
+          messageId: "noSentinelReturn"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-sequential-await.ts
+var import_utils9 = require("@typescript-eslint/utils");
+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_utils9.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-sequential-await",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow serial `await` inside a loop; use `await Promise.all(...)` to run the operations concurrently."
+    },
+    schema: [],
+    messages: {
+      noSequentialAwait: "Avoid `await` inside a loop \u2014 it serializes I/O. Collect the promises and `await Promise.all(xs.map(async (x) => ...))` instead."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function findAwaitInScope(node) {
+      if (node.type === "AwaitExpression") {
+        return node;
+      }
+      if (isFunctionLike(node)) {
+        return null;
+      }
+      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 (isNode2(child) && !isLoop(child)) {
+              const found = findAwaitInScope(child);
+              if (found) {
+                return found;
+              }
+            }
+          }
+        } else if (isNode2(value) && !isLoop(value)) {
+          const found = findAwaitInScope(value);
+          if (found) {
+            return found;
+          }
+        }
+      }
+      return null;
+    }
+    function isNode2(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;
+        }
+      }
+    }
+    return {
+      ForStatement: checkLoop,
+      ForInStatement: checkLoop,
+      WhileStatement: checkLoop,
+      DoWhileStatement: checkLoop,
+      ForOfStatement(node) {
+        if (node.await) {
+          return;
+        }
+        checkLoop(node);
+      }
+    };
+  }
+});
+
+// src/rules/no-string-concat-in-loop.ts
+var import_utils10 = require("@typescript-eslint/utils");
+var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ForStatement",
+  "ForOfStatement",
+  "ForInStatement",
+  "WhileStatement",
+  "DoWhileStatement"
+]);
+function isStringLiteralInit(node) {
+  if (node === null) {
+    return false;
+  }
+  if (node.type === "TemplateLiteral") {
+    return true;
+  }
+  if (node.type === "Literal") {
+    return typeof node.value === "string";
+  }
+  return false;
+}
+function findVariable(scope, name) {
+  let current = scope;
+  while (current !== null) {
+    const variable = current.variables.find((v) => v.name === name);
+    if (variable !== void 0) {
+      return variable;
+    }
+    current = current.upper;
+  }
+  return void 0;
+}
+function isStringInitializedVariable(variable) {
+  if (variable.defs.length !== 1) {
+    return false;
+  }
+  const def = variable.defs[0];
+  if (def === void 0 || def.type !== "Variable") {
+    return false;
+  }
+  const declarator = def.node;
+  if (declarator.type !== "VariableDeclarator") {
+    return false;
+  }
+  return isStringLiteralInit(declarator.init);
+}
+function isInsideLoopBody(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== void 0 && parent !== null) {
+    if (LOOP_NODE_TYPES.has(parent.type)) {
+      const loop = parent;
+      if (loop.body === child) {
+        return true;
+      }
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return false;
+}
+var no_string_concat_in_loop_default = import_utils10.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-string-concat-in-loop",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow O(n^2) string building via `+=` on a string variable inside a loop; push parts to an array and `join` instead."
+    },
+    schema: [],
+    messages: {
+      noStringConcatInLoop: 'Avoid building a string with `+=` inside a loop \u2014 this is O(n^2). Push the parts onto an array and use `arr.join("")` after the loop.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      AssignmentExpression(node) {
+        if (node.operator !== "+=") {
+          return;
+        }
+        if (node.left.type !== "Identifier") {
+          return;
+        }
+        if (!isInsideLoopBody(node)) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        const variable = findVariable(scope, node.left.name);
+        if (variable === void 0) {
+          return;
+        }
+        if (!isStringInitializedVariable(variable)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "noStringConcatInLoop"
+        });
+      }
+    };
+  }
+});
+
 // src/rules/no-unnecessary-use-client.ts
-var import_utils5 = require("@typescript-eslint/utils");
+var import_utils11 = 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?$/;
@@ -403,16 +946,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_utils5.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils5.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils11.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils11.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_utils5.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils11.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils5.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils11.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -429,7 +972,7 @@ var isGlobalReference = (node, context) => {
   }
   return true;
 };
-var no_unnecessary_use_client_default = import_utils5.ESLintUtils.RuleCreator(
+var no_unnecessary_use_client_default = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unnecessary-use-client",
@@ -452,13 +995,13 @@ var no_unnecessary_use_client_default = import_utils5.ESLintUtils.RuleCreator(
     let directiveNode = null;
     let hasClientIndicator = false;
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils5.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils11.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils5.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils5.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils11.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -468,7 +1011,7 @@ var no_unnecessary_use_client_default = import_utils5.ESLintUtils.RuleCreator(
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils5.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils11.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -479,7 +1022,7 @@ var no_unnecessary_use_client_default = import_utils5.ESLintUtils.RuleCreator(
         markIfHookOrContext(node.callee);
       },
       JSXAttribute(node) {
-        if (node.name.type === import_utils5.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils11.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -521,14 +1064,98 @@ var no_unnecessary_use_client_default = import_utils5.ESLintUtils.RuleCreator(
   }
 });
 
+// src/rules/prefer-discriminated-union.ts
+var import_utils12 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
+var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
+  "success",
+  "ok",
+  "error",
+  "failed",
+  "isError"
+]);
+var MIN_OPTIONAL_MEMBERS = 2;
+function getMemberName(member) {
+  if (member.type !== import_utils13.AST_NODE_TYPES.TSPropertySignature) {
+    return null;
+  }
+  const { key } = member;
+  if (key.type === import_utils13.AST_NODE_TYPES.Identifier) {
+    return key.name;
+  }
+  if (key.type === import_utils13.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
+}
+function isBooleanTyped(member) {
+  return member.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.TSBooleanKeyword;
+}
+function looksLikeMutuallyExclusiveState(typeLiteral) {
+  let hasStatusBoolean = false;
+  let optionalCount = 0;
+  for (const member of typeLiteral.members) {
+    if (member.type !== import_utils13.AST_NODE_TYPES.TSPropertySignature) {
+      continue;
+    }
+    if (member.optional) {
+      optionalCount += 1;
+    }
+    const name = getMemberName(member);
+    if (name !== null && STATUS_MEMBER_NAMES.has(name) && isBooleanTyped(member)) {
+      hasStatusBoolean = true;
+    }
+  }
+  return hasStatusBoolean && optionalCount >= MIN_OPTIONAL_MEMBERS;
+}
+var prefer_discriminated_union_default = import_utils12.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "prefer-discriminated-union",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag object types with a boolean status flag and many optionals; model them as a discriminated union instead."
+    },
+    schema: [],
+    messages: {
+      preferDiscriminatedUnion: "This object type uses a boolean status flag alongside several optional fields, which lets illegal states be representable. Model it as a `z.discriminatedUnion` / discriminated union (e.g. `{ ok: true; data: T } | { ok: false; error: E }`) to make illegal states unrepresentable."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkTypeLiteral(typeLiteral, reportNode) {
+      if (looksLikeMutuallyExclusiveState(typeLiteral)) {
+        context.report({
+          node: reportNode,
+          messageId: "preferDiscriminatedUnion"
+        });
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const synthetic = {
+          ...node.body,
+          type: import_utils13.AST_NODE_TYPES.TSTypeLiteral,
+          members: node.body.body
+        };
+        checkTypeLiteral(synthetic, node);
+      },
+      "TSTypeAliasDeclaration > TSTypeLiteral"(node) {
+        checkTypeLiteral(node, node.parent);
+      }
+    };
+  }
+});
+
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils6 = require("@typescript-eslint/utils");
+var import_utils14 = require("@typescript-eslint/utils");
 var unwrap = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils6.AST_NODE_TYPES.TSAsExpression || current.type === import_utils6.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils6.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils6.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils14.AST_NODE_TYPES.TSAsExpression || current.type === import_utils14.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils14.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils14.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils6.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils14.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -539,20 +1166,20 @@ var unwrap = (node) => {
 var isJsonCall = (node) => {
   let current = unwrap(node);
   if (current === null) return false;
-  if (current.type === import_utils6.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils14.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap(current.argument);
   }
-  if (current === null || current.type !== import_utils6.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils14.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap(current.callee);
-  if (callee === null || callee.type !== import_utils6.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils14.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap(callee.property);
-  return property !== null && property.type === import_utils6.AST_NODE_TYPES.Identifier && property.name === "json";
+  return property !== null && property.type === import_utils14.AST_NODE_TYPES.Identifier && property.name === "json";
 };
-var findVariable = (scope, name) => {
+var findVariable2 = (scope, name) => {
   let current = scope;
   while (current !== null) {
     const variable = current.set.get(name);
@@ -563,13 +1190,13 @@ var findVariable = (scope, name) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
-  if (unwrapped === null || unwrapped.type !== import_utils6.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils14.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  const variable = findVariable(scope, unwrapped.name);
+  const variable = findVariable2(scope, unwrapped.name);
   return variable !== null && tracked.has(variable);
 };
-var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreator(
+var prefer_schema_for_api_payload_default = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-schema-for-api-payload",
@@ -597,11 +1224,11 @@ var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreato
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils6.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils14.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils6.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils6.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils14.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils14.AST_NODE_TYPES.ArrayPattern) {
           if (isJsonCall(node.init)) {
             context.report({ node: node.id, messageId: "unparsedJsonAccess" });
             return;
@@ -613,8 +1240,8 @@ var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreato
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils6.AST_NODE_TYPES.Identifier) {
-          const variable = findVariable(scope, node.left.name);
+        if (node.left.type === import_utils14.AST_NODE_TYPES.Identifier) {
+          const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isJsonCall(node.right)) {
             unvalidatedVariables.add(variable);
@@ -623,7 +1250,7 @@ var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreato
           }
           return;
         }
-        if (node.left.type === import_utils6.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils6.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils14.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils14.AST_NODE_TYPES.ArrayPattern) {
           if (isJsonCall(node.right)) {
             context.report({
               node: node.left,
@@ -644,15 +1271,15 @@ var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreato
         const obj = unwrap(node.object);
         if (isJsonCall(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils6.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils6.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
+          if (parent.type === import_utils14.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils14.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_utils6.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils14.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
-          const variable = findVariable(scope, obj.name);
+          const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
             unvalidatedVariables.delete(variable);
           }
@@ -663,7 +1290,7 @@ var prefer_schema_for_api_payload_default = import_utils6.ESLintUtils.RuleCreato
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils15 = 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\/)/;
@@ -742,7 +1369,7 @@ function getPropertyNode(objNode, propName) {
   }
   return null;
 }
-var prefer_server_actions_default = import_utils7.ESLintUtils.RuleCreator(
+var prefer_server_actions_default = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-server-actions",
@@ -807,14 +1434,14 @@ var prefer_server_actions_default = import_utils7.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-shadcn.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils16 = require("@typescript-eslint/utils");
 var REPLACEMENTS = {
   input: "Input",
   select: "Select",
   textarea: "Textarea",
   dialog: "Dialog"
 };
-var prefer_shadcn_default = import_utils8.ESLintUtils.RuleCreator(
+var prefer_shadcn_default = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-shadcn",
@@ -855,25 +1482,25 @@ var prefer_shadcn_default = import_utils8.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-assert-never.ts
-var import_utils9 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils9.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils17.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  return callee.type === import_utils9.AST_NODE_TYPES.Identifier && callee.name === "assertNever";
+  return callee.type === import_utils17.AST_NODE_TYPES.Identifier && callee.name === "assertNever";
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === import_utils9.AST_NODE_TYPES.ExpressionStatement) {
+  if (statement.type === import_utils17.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils9.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils17.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils17.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
-var require_assert_never_default = import_utils9.ESLintUtils.RuleCreator(
+var require_assert_never_default = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-assert-never",
@@ -909,22 +1536,22 @@ var require_assert_never_default = import_utils9.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var isFormDataGetCall = (node) => {
   const callee = node.callee;
-  if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression) return false;
-  if (callee.property.type !== import_utils10.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+  if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.property.type !== import_utils18.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
     return false;
   }
-  return callee.object.type === import_utils10.AST_NODE_TYPES.Identifier && callee.object.name === "formData";
+  return callee.object.type === import_utils18.AST_NODE_TYPES.Identifier && callee.object.name === "formData";
 };
 var isParseCallExpression = (node) => {
-  if (node.type !== import_utils10.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils18.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression) return false;
-  return callee.property.type === import_utils10.AST_NODE_TYPES.Identifier && callee.property.name === "parse";
+  if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression) return false;
+  return callee.property.type === import_utils18.AST_NODE_TYPES.Identifier && callee.property.name === "parse";
 };
-var require_zod_form_validation_default = import_utils10.ESLintUtils.RuleCreator(
+var require_zod_form_validation_default = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-zod-form-validation",
@@ -958,15 +1585,15 @@ var require_zod_form_validation_default = import_utils10.ESLintUtils.RuleCreator
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils11.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils19.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils11.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils19.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils11.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils19.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -974,7 +1601,7 @@ var calleeChainStartsWithZ = (node) => {
   }
   return false;
 };
-var zod_naming_convention_default = import_utils11.ESLintUtils.RuleCreator(
+var zod_naming_convention_default = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "zod-naming-convention",
@@ -994,11 +1621,11 @@ var zod_naming_convention_default = import_utils11.ESLintUtils.RuleCreator(
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils11.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils19.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils19.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
-        if (node.id.type !== import_utils11.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils19.AST_NODE_TYPES.Identifier) return;
         const variableName = node.id.name;
         if (variableName.startsWith("Z")) return;
         context.report({
@@ -1015,8 +1642,15 @@ var rules = {
   "enforce-file-structure": enforce_file_structure_default,
   "no-client-side-data-fetching": no_client_side_data_fetching_default,
   "no-enum": no_enum_default,
+  "no-insecure-random-id": no_insecure_random_id_default,
+  "no-json-stringify-error": no_json_stringify_error_default,
+  "no-log-only-catch": no_log_only_catch_default,
   "no-raw-env": no_raw_env_default,
+  "no-sentinel-return-on-catch": no_sentinel_return_on_catch_default,
+  "no-sequential-await": no_sequential_await_default,
+  "no-string-concat-in-loop": no_string_concat_in_loop_default,
   "no-unnecessary-use-client": no_unnecessary_use_client_default,
+  "prefer-discriminated-union": prefer_discriminated_union_default,
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
   "prefer-server-actions": prefer_server_actions_default,
   "prefer-shadcn": prefer_shadcn_default,
@@ -1027,7 +1661,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.0.0"
+    version: "2.1.1"
   },
   rules,
   configs: {
@@ -1041,7 +1675,15 @@ var plugin = {
         "@sarj/no-client-side-data-fetching": "warn",
         "@sarj/prefer-server-actions": "warn",
         "@sarj/no-unnecessary-use-client": "warn",
-        "@sarj/prefer-schema-for-api-payload": "warn"
+        "@sarj/prefer-schema-for-api-payload": "warn",
+        // Distilled from sarj-audit skills — warn in recommended, error in strict.
+        "@sarj/no-sequential-await": "warn",
+        "@sarj/no-sentinel-return-on-catch": "warn",
+        "@sarj/no-log-only-catch": "warn",
+        "@sarj/no-insecure-random-id": "warn",
+        "@sarj/no-json-stringify-error": "warn",
+        "@sarj/no-string-concat-in-loop": "warn",
+        "@sarj/prefer-discriminated-union": "warn"
       }
     },
     strict: {
@@ -1057,7 +1699,15 @@ var plugin = {
         "@sarj/no-client-side-data-fetching": "error",
         "@sarj/prefer-server-actions": "error",
         "@sarj/no-unnecessary-use-client": "error",
-        "@sarj/prefer-schema-for-api-payload": "error"
+        "@sarj/prefer-schema-for-api-payload": "error",
+        // Distilled from sarj-audit skills.
+        "@sarj/no-sequential-await": "error",
+        "@sarj/no-sentinel-return-on-catch": "error",
+        "@sarj/no-log-only-catch": "error",
+        "@sarj/no-insecure-random-id": "error",
+        "@sarj/no-json-stringify-error": "error",
+        "@sarj/no-string-concat-in-loop": "error",
+        "@sarj/prefer-discriminated-union": "error"
       }
     }
   }