@noctcore/eslint-plugin-async-safety 0.1.0

package/dist/index.js

@@ -0,0 +1,819 @@
+// src/configs/recommended.ts
+var recommended = {
+  // Precise, syntactic — safe as errors.
+  "noctcore-async-safety/require-fetch-timeout": "error",
+  // Inert until you set `include` globs, so it ships enabled but off by default.
+  "noctcore-async-safety/no-shared-mutable-module-state": "error",
+  // Heuristic — advisory. Warns rather than blocking.
+  "noctcore-async-safety/forward-abort-signal": "warn",
+  "noctcore-async-safety/prefer-parallel-awaits": "warn",
+  "noctcore-async-safety/no-concurrent-shared-mutation": "warn"
+};
+
+// src/rules/forward-abort-signal.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+
+// src/createRule.ts
+import { makeCreateRule } from "@noctcore/eslint-utils";
+var createRule = makeCreateRule("async-safety");
+
+// src/utils.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+function calleeText(callee) {
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed) {
+    const object = calleeText(callee.object);
+    if (object === null || callee.property.type !== AST_NODE_TYPES.Identifier) {
+      return null;
+    }
+    return `${object}.${callee.property.name}`;
+  }
+  return null;
+}
+function globToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        i += 1;
+        if (glob[i + 1] === "/") {
+          i += 1;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(char)) {
+      source += `\\${char}`;
+    } else {
+      source += char;
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+function matchesAnyGlob(filename, globs) {
+  if (globs.length === 0) {
+    return false;
+  }
+  const normalized = filename.split("\\").join("/");
+  return globs.some((glob) => globToRegExp(glob).test(normalized));
+}
+function walk(node, visit) {
+  visit(node);
+  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 (isNode(child)) {
+          walk(child, visit);
+        }
+      }
+    } else if (isNode(value)) {
+      walk(value, visit);
+    }
+  }
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+
+// src/rules/forward-abort-signal.ts
+var RULE_NAME = "forward-abort-signal";
+function signalBindingNames(params) {
+  const names = /* @__PURE__ */ new Set();
+  let reportNode = null;
+  const consider = (name, node) => {
+    names.add(name);
+    reportNode ??= node;
+  };
+  for (const rawParam of params) {
+    let param = rawParam;
+    if (param.type === AST_NODE_TYPES2.AssignmentPattern) {
+      param = param.left;
+    }
+    if (param.type === AST_NODE_TYPES2.Identifier) {
+      const typedAbortSignal = param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES2.TSTypeReference && param.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES2.Identifier && param.typeAnnotation.typeAnnotation.typeName.name === "AbortSignal";
+      if (param.name === "signal" || typedAbortSignal) {
+        consider(param.name, param);
+      }
+      continue;
+    }
+    if (param.type === AST_NODE_TYPES2.ObjectPattern) {
+      for (const property of param.properties) {
+        if (property.type !== AST_NODE_TYPES2.Property || property.key.type !== AST_NODE_TYPES2.Identifier || property.key.name !== "signal") {
+          continue;
+        }
+        let value = property.value;
+        if (value.type === AST_NODE_TYPES2.AssignmentPattern) {
+          value = value.left;
+        }
+        if (value.type === AST_NODE_TYPES2.Identifier) {
+          consider(value.name, property);
+        }
+      }
+    }
+  }
+  return { names, reportNode };
+}
+function hasCancellableWork(fn) {
+  let found = false;
+  walk(fn, (node) => {
+    if (found) {
+      return;
+    }
+    if (node.type === AST_NODE_TYPES2.AwaitExpression && node.argument.type === AST_NODE_TYPES2.CallExpression) {
+      found = true;
+      return;
+    }
+    if (node.type === AST_NODE_TYPES2.CallExpression && calleeText(node.callee) === "fetch") {
+      found = true;
+    }
+  });
+  return found;
+}
+function isCheckOnlyRead(identifier) {
+  const parent = identifier.parent;
+  return parent.type === AST_NODE_TYPES2.MemberExpression && parent.object === identifier;
+}
+var forwardAbortSignalRule = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A function that accepts an `AbortSignal` (param named `signal` or typed `AbortSignal`) but awaits a call without ever forwarding it leaves that work uncancellable."
+    },
+    schema: [],
+    messages: {
+      unforwardedSignal: "`{{name}}` is an AbortSignal but is never forwarded to a call in this function \u2014 thread it into the awaited work (e.g. `fetch(url, { signal })`) so the operation can be cancelled."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function check(fn) {
+      const { names, reportNode } = signalBindingNames(fn.params);
+      if (names.size === 0 || reportNode === null) {
+        return;
+      }
+      if (!hasCancellableWork(fn)) {
+        return;
+      }
+      const declared = context.sourceCode.getDeclaredVariables(fn);
+      for (const variable of declared) {
+        if (!names.has(variable.name)) {
+          continue;
+        }
+        const reads = variable.references.filter((ref) => ref.isRead());
+        const forwarded = reads.some(
+          (ref) => ref.identifier.type === AST_NODE_TYPES2.Identifier && !isCheckOnlyRead(ref.identifier)
+        );
+        if (!forwarded) {
+          context.report({
+            node: reportNode,
+            messageId: "unforwardedSignal",
+            data: { name: variable.name }
+          });
+          return;
+        }
+      }
+    }
+    return {
+      FunctionDeclaration: check,
+      FunctionExpression: check,
+      ArrowFunctionExpression: check
+    };
+  }
+});
+
+// src/rules/no-concurrent-shared-mutation.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var RULE_NAME2 = "no-concurrent-shared-mutation";
+var CONCURRENT_ITERATORS = /* @__PURE__ */ new Set(["map", "flatMap", "forEach"]);
+function isPromiseConcurrency(callee) {
+  return callee.type === AST_NODE_TYPES3.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES3.Identifier && callee.object.name === "Promise" && callee.property.type === AST_NODE_TYPES3.Identifier && (callee.property.name === "all" || callee.property.name === "allSettled");
+}
+function asyncIterationCallback(node) {
+  if (node.type !== AST_NODE_TYPES3.CallExpression || node.callee.type !== AST_NODE_TYPES3.MemberExpression || node.callee.computed || node.callee.property.type !== AST_NODE_TYPES3.Identifier || !CONCURRENT_ITERATORS.has(node.callee.property.name)) {
+    return null;
+  }
+  const callback = node.arguments[node.arguments.length - 1];
+  if (callback !== void 0 && (callback.type === AST_NODE_TYPES3.ArrowFunctionExpression || callback.type === AST_NODE_TYPES3.FunctionExpression) && callback.async) {
+    return callback;
+  }
+  return null;
+}
+function containsAwait(node) {
+  let found = false;
+  walk(node, (inner) => {
+    if (inner.type === AST_NODE_TYPES3.AwaitExpression) {
+      found = true;
+    }
+  });
+  return found;
+}
+function referencedNames(node) {
+  const names = /* @__PURE__ */ new Set();
+  walk(node, (inner) => {
+    if (inner.type === AST_NODE_TYPES3.Identifier) {
+      names.add(inner.name);
+    }
+  });
+  return names;
+}
+function resolveVariable(scope, name) {
+  for (let current = scope; current; current = current.upper) {
+    const variable = current.set.get(name);
+    if (variable) {
+      return variable;
+    }
+  }
+  return null;
+}
+var noConcurrentSharedMutationRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A read-modify-write of an outer-scope binding inside a concurrent `Promise.all(arr.map(async \u2026))` callback can lose updates."
+    },
+    schema: [],
+    messages: {
+      concurrentMutation: "`{{name}}` is read-modified-written inside a concurrent `Promise.all` callback \u2014 interleaved iterations can lose updates. Collect results into an array and reduce after the `Promise.all`, or update atomically."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const reported = /* @__PURE__ */ new Set();
+    function isOuterWrite(id, callback) {
+      const variable = resolveVariable(context.sourceCode.getScope(id), id.name);
+      const def = variable?.defs[0];
+      if (def === void 0) {
+        return false;
+      }
+      const defRange = def.name.range;
+      const inside = defRange[0] >= callback.range[0] && defRange[1] <= callback.range[1];
+      return !inside;
+    }
+    function checkCallback(callback) {
+      if (!containsAwait(callback)) {
+        return;
+      }
+      walk(callback, (node) => {
+        if (node.type === AST_NODE_TYPES3.UpdateExpression) {
+          const arg = node.argument;
+          if (arg.type === AST_NODE_TYPES3.Identifier && !reported.has(arg) && isOuterWrite(arg, callback)) {
+            reported.add(arg);
+            context.report({ node: arg, messageId: "concurrentMutation", data: { name: arg.name } });
+          }
+          return;
+        }
+        if (node.type === AST_NODE_TYPES3.AssignmentExpression && node.left.type === AST_NODE_TYPES3.Identifier) {
+          const left = node.left;
+          const compound = node.operator !== "=";
+          const selfReferential = node.operator === "=" && referencedNames(node.right).has(left.name);
+          if ((compound || selfReferential) && !reported.has(left) && isOuterWrite(left, callback)) {
+            reported.add(left);
+            context.report({ node: left, messageId: "concurrentMutation", data: { name: left.name } });
+          }
+        }
+      });
+    }
+    return {
+      CallExpression(node) {
+        if (!isPromiseConcurrency(node.callee)) {
+          return;
+        }
+        const arg = node.arguments[0];
+        if (arg === void 0 || arg.type === AST_NODE_TYPES3.SpreadElement) {
+          return;
+        }
+        walk(arg, (inner) => {
+          const callback = asyncIterationCallback(inner);
+          if (callback !== null) {
+            checkCallback(callback);
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-shared-mutable-module-state.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+var RULE_NAME3 = "no-shared-mutable-module-state";
+var CONTAINER_CTORS = /* @__PURE__ */ new Set([
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Array"
+]);
+var MUTATING_METHODS = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin",
+  "set",
+  "add",
+  "delete",
+  "clear"
+]);
+var HANDLER_NAMES = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "loader",
+  "action",
+  "handler",
+  "middleware"
+]);
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    include: { type: "array", items: { type: "string" }, uniqueItems: true },
+    allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function isHandlerName(name) {
+  return name !== null && (HANDLER_NAMES.has(name) || name.endsWith("Handler"));
+}
+function qualifies(fn, name) {
+  return fn.async || isHandlerName(name);
+}
+function isContainerInit(init) {
+  if (!init) {
+    return false;
+  }
+  if (init.type === AST_NODE_TYPES4.ArrayExpression || init.type === AST_NODE_TYPES4.ObjectExpression) {
+    return true;
+  }
+  return init.type === AST_NODE_TYPES4.NewExpression && init.callee.type === AST_NODE_TYPES4.Identifier && CONTAINER_CTORS.has(init.callee.name);
+}
+function classify(variable) {
+  const def = variable.defs[0];
+  if (def === void 0 || def.type !== "Variable" || def.parent.type !== AST_NODE_TYPES4.VariableDeclaration) {
+    return null;
+  }
+  const kind = def.parent.kind;
+  if (kind === "let" || kind === "var") {
+    return { reassignable: true };
+  }
+  const declarator = def.node;
+  if (declarator.type === AST_NODE_TYPES4.VariableDeclarator && isContainerInit(declarator.init)) {
+    return { reassignable: false };
+  }
+  return null;
+}
+function isLazyInit(identifier) {
+  const parent = identifier.parent;
+  return parent.type === AST_NODE_TYPES4.AssignmentExpression && parent.left === identifier && (parent.operator === "??=" || parent.operator === "||=");
+}
+function isContainerMutation(identifier) {
+  const member = identifier.parent;
+  if (member.type !== AST_NODE_TYPES4.MemberExpression || member.object !== identifier) {
+    return false;
+  }
+  const outer = member.parent;
+  if (outer.type === AST_NODE_TYPES4.AssignmentExpression && outer.left === member) {
+    return true;
+  }
+  if (outer.type === AST_NODE_TYPES4.UpdateExpression && outer.argument === member) {
+    return true;
+  }
+  return outer.type === AST_NODE_TYPES4.CallExpression && outer.callee === member && !member.computed && member.property.type === AST_NODE_TYPES4.Identifier && MUTATING_METHODS.has(member.property.name);
+}
+function moduleScopeOf(scope) {
+  if (scope.type === "module") {
+    return scope;
+  }
+  const child = scope.childScopes.find((inner) => inner.type === "module");
+  return child ?? scope;
+}
+function enclosingExportedFn(node, exported) {
+  for (let current = node.parent; current; current = current.parent) {
+    if (exported.has(current)) {
+      return exported.get(current);
+    }
+  }
+  return void 0;
+}
+function collectExportedFns(program) {
+  const result = /* @__PURE__ */ new Map();
+  const addFn = (fn, name) => {
+    if (qualifies(fn, name)) {
+      result.set(fn, name);
+    }
+  };
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES4.ExportNamedDeclaration && statement.declaration) {
+      const decl = statement.declaration;
+      if (decl.type === AST_NODE_TYPES4.FunctionDeclaration) {
+        addFn(decl, decl.id ? decl.id.name : null);
+      } else if (decl.type === AST_NODE_TYPES4.VariableDeclaration) {
+        for (const d of decl.declarations) {
+          if (d.id.type === AST_NODE_TYPES4.Identifier && d.init && (d.init.type === AST_NODE_TYPES4.ArrowFunctionExpression || d.init.type === AST_NODE_TYPES4.FunctionExpression)) {
+            addFn(d.init, d.id.name);
+          }
+        }
+      }
+    } else if (statement.type === AST_NODE_TYPES4.ExportDefaultDeclaration) {
+      const decl = statement.declaration;
+      if (decl.type === AST_NODE_TYPES4.FunctionDeclaration || decl.type === AST_NODE_TYPES4.ArrowFunctionExpression || decl.type === AST_NODE_TYPES4.FunctionExpression) {
+        addFn(decl, decl.type === AST_NODE_TYPES4.FunctionDeclaration && decl.id ? decl.id.name : null);
+      }
+    }
+  }
+  return result;
+}
+var noSharedMutableModuleStateRule = createRule({
+  name: RULE_NAME3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A module-scoped mutable binding written inside an exported async/handler function is shared across concurrent requests. Opt in per file via `include`."
+    },
+    schema: [optionSchema],
+    messages: {
+      sharedMutableState: "Module-scoped mutable `{{name}}` is written inside exported `{{fn}}` \u2014 concurrent requests share this state and can contaminate each other. Scope it per request, or guard it."
+    }
+  },
+  defaultOptions: [{ include: [], allow: [] }],
+  create(context, [options]) {
+    const include = options.include ?? [];
+    if (!matchesAnyGlob(context.filename, include)) {
+      return {};
+    }
+    const allow = new Set(options.allow ?? []);
+    return {
+      Program(program) {
+        const exported = collectExportedFns(program);
+        if (exported.size === 0) {
+          return;
+        }
+        const moduleScope = moduleScopeOf(context.sourceCode.getScope(program));
+        for (const variable of moduleScope.variables) {
+          if (allow.has(variable.name)) {
+            continue;
+          }
+          const binding = classify(variable);
+          if (binding === null) {
+            continue;
+          }
+          for (const ref of variable.references) {
+            const id = ref.identifier;
+            if (id.type !== AST_NODE_TYPES4.Identifier) {
+              continue;
+            }
+            let isWrite = false;
+            if (binding.reassignable && ref.isWrite() && !ref.init) {
+              if (isLazyInit(id)) {
+                continue;
+              }
+              isWrite = true;
+            } else if (ref.isRead() && isContainerMutation(id)) {
+              isWrite = true;
+            }
+            if (!isWrite) {
+              continue;
+            }
+            const fnName = enclosingExportedFn(id, exported);
+            if (fnName === void 0) {
+              continue;
+            }
+            context.report({
+              node: id,
+              messageId: "sharedMutableState",
+              data: { name: variable.name, fn: fnName ?? "default export" }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-parallel-awaits.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+var RULE_NAME4 = "prefer-parallel-awaits";
+var MUTATION_PREFIXES = [
+  "set",
+  "save",
+  "update",
+  "upsert",
+  "insert",
+  "create",
+  "delete",
+  "destroy",
+  "remove",
+  "drop",
+  "write",
+  "put",
+  "post",
+  "patch",
+  "send",
+  "push",
+  "add",
+  "emit",
+  "dispatch",
+  "publish",
+  "begin",
+  "commit",
+  "rollback",
+  "mutate",
+  "sync"
+];
+function asAwaitDecl(statement) {
+  if (statement.type !== AST_NODE_TYPES5.VariableDeclaration || statement.kind !== "const" || statement.declarations.length !== 1) {
+    return null;
+  }
+  const declarator = statement.declarations[0];
+  if (declarator === void 0 || declarator.id.type !== AST_NODE_TYPES5.Identifier || declarator.init?.type !== AST_NODE_TYPES5.AwaitExpression || declarator.init.argument.type !== AST_NODE_TYPES5.CallExpression) {
+    return null;
+  }
+  return { statement, name: declarator.id.name, call: declarator.init.argument };
+}
+function calleeLastName(callee) {
+  if (callee.type === AST_NODE_TYPES5.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === AST_NODE_TYPES5.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES5.Identifier) {
+    return callee.property.name;
+  }
+  return null;
+}
+function looksLikeMutation(name) {
+  const lower = name.toLowerCase();
+  return MUTATION_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+function isSimpleReadCall(call) {
+  const name = calleeLastName(call.callee);
+  if (name === null || looksLikeMutation(name)) {
+    return false;
+  }
+  let clean = true;
+  walk(call, (node) => {
+    if (node === call || !clean) {
+      return;
+    }
+    if (node.type === AST_NODE_TYPES5.CallExpression || node.type === AST_NODE_TYPES5.NewExpression || node.type === AST_NODE_TYPES5.AwaitExpression || node.type === AST_NODE_TYPES5.AssignmentExpression || node.type === AST_NODE_TYPES5.UpdateExpression || node.type === AST_NODE_TYPES5.TaggedTemplateExpression) {
+      clean = false;
+    }
+  });
+  return clean;
+}
+function referencedNames2(node) {
+  const names = /* @__PURE__ */ new Set();
+  walk(node, (inner) => {
+    if (inner.type === AST_NODE_TYPES5.Identifier) {
+      names.add(inner.name);
+    }
+  });
+  return names;
+}
+var preferParallelAwaitsRule = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Consecutive independent `const x = await read()` statements can run concurrently via `await Promise.all([...])`."
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      parallelizable: "{{count}} consecutive independent awaits run sequentially \u2014 they have no data dependency and could run concurrently with `await Promise.all([...])`.",
+      useParallel: "Combine into a single `await Promise.all([...])`."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkBlock(node) {
+      const body = node.body;
+      for (let i = 0; i < body.length; ) {
+        const first = body[i];
+        if (first === void 0 || asAwaitDecl(first) === null) {
+          i += 1;
+          continue;
+        }
+        const run = [];
+        let j = i;
+        for (; j < body.length; j += 1) {
+          const statement = body[j];
+          const decl = statement === void 0 ? null : asAwaitDecl(statement);
+          if (decl === null) {
+            break;
+          }
+          run.push(decl);
+        }
+        if (run.length >= 2 && isParallelizable(run)) {
+          reportRun(run);
+        }
+        i = j > i ? j : i + 1;
+      }
+    }
+    function isParallelizable(run) {
+      const introduced = /* @__PURE__ */ new Set();
+      for (const decl of run) {
+        if (!isSimpleReadCall(decl.call)) {
+          return false;
+        }
+        const used = referencedNames2(decl.call);
+        for (const name of introduced) {
+          if (used.has(name)) {
+            return false;
+          }
+        }
+        introduced.add(decl.name);
+      }
+      return true;
+    }
+    function reportRun(run) {
+      const firstDecl = run[0];
+      const lastDecl = run[run.length - 1];
+      if (firstDecl === void 0 || lastDecl === void 0) {
+        return;
+      }
+      const names = run.map((decl) => decl.name);
+      const exprs = run.map((decl) => context.sourceCode.getText(decl.call));
+      const replacement = `const [${names.join(", ")}] = await Promise.all([${exprs.join(", ")}]);`;
+      context.report({
+        node: firstDecl.statement,
+        messageId: "parallelizable",
+        data: { count: run.length },
+        suggest: [
+          {
+            messageId: "useParallel",
+            fix: (fixer) => fixer.replaceTextRange(
+              [firstDecl.statement.range[0], lastDecl.statement.range[1]],
+              replacement
+            )
+          }
+        ]
+      });
+    }
+    return {
+      BlockStatement: checkBlock
+    };
+  }
+});
+
+// src/rules/require-fetch-timeout.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var RULE_NAME5 = "require-fetch-timeout";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var SIGNAL_KEYS = /* @__PURE__ */ new Set(["signal", "timeout"]);
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    callees: { type: "array", items: { type: "string" }, uniqueItems: true },
+    defaultTimeoutMs: { type: "integer", minimum: 1 }
+  }
+};
+function isUrlLike(node) {
+  return node.type === AST_NODE_TYPES6.TemplateLiteral || node.type === AST_NODE_TYPES6.Literal && typeof node.value === "string";
+}
+function probeOptionsObject(object) {
+  for (const property of object.properties) {
+    if (property.type === AST_NODE_TYPES6.SpreadElement) {
+      return { satisfied: false, opaque: true };
+    }
+    const key = property.key;
+    const name = key.type === AST_NODE_TYPES6.Identifier ? key.name : key.type === AST_NODE_TYPES6.Literal && typeof key.value === "string" ? key.value : null;
+    if (name !== null && SIGNAL_KEYS.has(name)) {
+      return { satisfied: true, opaque: false };
+    }
+  }
+  return { satisfied: false, opaque: false };
+}
+var requireFetchTimeoutRule = createRule({
+  name: RULE_NAME5,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A `fetch` (or configured wrapper) call must carry a `signal`/`timeout` in its options \u2014 an unbounded request can hang forever."
+    },
+    hasSuggestions: true,
+    schema: [optionSchema2],
+    messages: {
+      missingTimeout: "`{{callee}}` has no timeout \u2014 pass a `signal` (e.g. `AbortSignal.timeout({{ms}})`) or a `timeout` option so the request cannot hang indefinitely.",
+      addTimeout: "Add `signal: AbortSignal.timeout({{ms}})`."
+    }
+  },
+  defaultOptions: [{ callees: [], defaultTimeoutMs: DEFAULT_TIMEOUT_MS }],
+  create(context, [options]) {
+    const timeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const matched = /* @__PURE__ */ new Set(["fetch", ...options.callees ?? []]);
+    return {
+      CallExpression(node) {
+        const name = calleeText(node.callee);
+        if (name === null || !matched.has(name)) {
+          return;
+        }
+        const args = node.arguments;
+        if (args.some((arg) => arg.type === AST_NODE_TYPES6.SpreadElement)) {
+          return;
+        }
+        const objectArgs = args.filter(
+          (arg) => arg.type === AST_NODE_TYPES6.ObjectExpression
+        );
+        if (objectArgs.length > 0) {
+          const probes = objectArgs.map(probeOptionsObject);
+          if (probes.some((probe) => probe.satisfied || probe.opaque)) {
+            return;
+          }
+          const target = objectArgs[objectArgs.length - 1];
+          if (target === void 0) {
+            return;
+          }
+          context.report({
+            node: node.callee,
+            messageId: "missingTimeout",
+            data: { callee: name, ms: timeoutMs },
+            suggest: [
+              {
+                messageId: "addTimeout",
+                data: { ms: timeoutMs },
+                fix: (fixer) => {
+                  const insertion = `signal: AbortSignal.timeout(${timeoutMs})`;
+                  const first = target.properties[0];
+                  if (first === void 0) {
+                    return fixer.replaceText(target, `{ ${insertion} }`);
+                  }
+                  return fixer.insertTextBefore(first, `${insertion}, `);
+                }
+              }
+            ]
+          });
+          return;
+        }
+        if (args.length === 0 || !args.every(isUrlLike)) {
+          return;
+        }
+        const lastArg = args[args.length - 1];
+        if (lastArg === void 0) {
+          return;
+        }
+        context.report({
+          node: node.callee,
+          messageId: "missingTimeout",
+          data: { callee: name, ms: timeoutMs },
+          suggest: [
+            {
+              messageId: "addTimeout",
+              data: { ms: timeoutMs },
+              fix: (fixer) => fixer.insertTextAfter(lastArg, `, { signal: AbortSignal.timeout(${timeoutMs}) }`)
+            }
+          ]
+        });
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "require-fetch-timeout": requireFetchTimeoutRule,
+  "forward-abort-signal": forwardAbortSignalRule,
+  "no-shared-mutable-module-state": noSharedMutableModuleStateRule,
+  "prefer-parallel-awaits": preferParallelAwaitsRule,
+  "no-concurrent-shared-mutation": noConcurrentSharedMutationRule
+};
+
+// src/index.ts
+var NAMESPACE = "noctcore-async-safety";
+var VERSION = "0.1.0";
+var plugin = {
+  meta: { name: "@noctcore/eslint-plugin-async-safety", version: VERSION },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { [NAMESPACE]: plugin },
+  rules: recommended
+};
+var configs = plugin.configs;
+var index_default = plugin;
+export {
+  configs,
+  index_default as default,
+  rules
+};