@sarj/eslint-plugin 16.4.7 → 16.5.0

package/dist/index.cjs

@@ -49,6 +49,125 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// package.json
+var package_default = {
+  name: "@sarj/eslint-plugin",
+  version: "16.5.0",
+  packageManager: "npm@12.1.0",
+  description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  sideEffects: false,
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sarj-ai/code-standards.git",
+    directory: "packages/typescript"
+  },
+  homepage: "https://code-standards.sarj.ai/rules/eslint/",
+  bugs: {
+    url: "https://github.com/sarj-ai/code-standards/issues"
+  },
+  scripts: {
+    build: "tsup",
+    dogfood: "npm run build && npm run dogfood:built",
+    lint: "eslint . ../../.github/scripts ../standards/src ../standards/eslint.config.mjs --max-warnings 0",
+    prepack: "npm run build && npm run verify-package",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    "verify-package": `node -e "const fs=require('node:fs'),p=require('./package.json'),walk=x=>typeof x==='string'?[x]:x&&typeof x==='object'?Object.values(x).flatMap(walk):[];for(const file of new Set([p.main,p.module,p.types,...walk(p.exports)].filter(Boolean).map(x=>x.startsWith('./')?x.slice(2):x))){if(!file.startsWith('dist/'))throw new Error('export must live under dist: '+file);const stat=fs.statSync(file);if(!stat.isFile()||stat.size===0)throw new Error('missing or empty export: '+file)}"`,
+    "dogfood:built": `eslint --config eslint.dogfood.config.mjs src tests eslint.config.mjs eslint.dogfood.config.mjs module-constant-naming-options.mjs tsup.config.ts vitest.config.ts --max-warnings 0 && node -e "import('./dist/index.js').then(({default:p}) => console.log('dogfood: '+Object.keys(p.rules).length+' TypeScript rules, 0 diagnostics'))"`
+  },
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "sarj",
+    "react",
+    "nextjs",
+    "zod"
+  ],
+  author: "sarj-ai",
+  license: "MIT",
+  dependencies: {
+    "@typescript-eslint/typescript-estree": "^8.70.1",
+    "@typescript-eslint/utils": "^8.70.1",
+    "jsonc-parser": "^3.3.1"
+  },
+  devDependencies: {
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
+    "@eslint/compat": "^2.1.1",
+    "@eslint/js": "10.0.1",
+    "@shadcn/lint": "0.2.0",
+    "@types/node": "26.6.2",
+    "@typescript-eslint/parser": "8.70.1",
+    "@typescript-eslint/rule-tester": "8.70.1",
+    "@typescript-eslint/utils": "8.70.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "@vitest/eslint-plugin": "1.6.27",
+    eslint: "10.11.0",
+    "eslint-node-test": "0.4.0",
+    "eslint-plugin-better-tailwindcss": "^4.7.0",
+    "eslint-plugin-jest": "29.16.6",
+    "eslint-plugin-jsdoc": "64.5.4",
+    "eslint-plugin-n": "^18.3.0",
+    "eslint-plugin-perfectionist": "5.12.1",
+    "eslint-plugin-playwright": "2.12.0",
+    "eslint-plugin-promise": "^7.3.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "eslint-plugin-testing-library": "7.16.2",
+    "eslint-plugin-unicorn": "^76.0.0",
+    "eslint-plugin-zod": "^4.14.2",
+    globals: "15.15.0",
+    tsup: "latest",
+    typescript: "npm:@typescript/typescript6@6.0.2",
+    "typescript-eslint": "^8.70.1",
+    vitest: "5.0.1"
+  },
+  peerDependencies: {
+    eslint: ">=9.39.4",
+    typescript: ">=5.0.0"
+  },
+  engines: {
+    node: ">=22.22.2"
+  },
+  allowScripts: {
+    "esbuild@0.28.2": true,
+    "fsevents@2.3.3": true
+  },
+  peerDependenciesMeta: {
+    typescript: {
+      optional: true
+    }
+  },
+  overrides: {
+    "brace-expansion@^5.0.0": "5.0.9",
+    esbuild: "0.28.2",
+    "nanoid@<3.3.18": "3.3.18",
+    "eslint-plugin-react": {
+      eslint: "$eslint"
+    }
+  }
+};
+
 // src/rules/require-explicit-contract-implementation.ts
 var import_utils2 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
@@ -4794,6 +4913,41 @@ function staticString(node) {
   if (value.type === import_utils29.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
   return value.type === import_utils29.AST_NODE_TYPES.TemplateLiteral && value.expressions.length === 0 ? value.quasis[0]?.value.cooked ?? null : null;
 }
+var SCOPED_STRING_VALUES = /* @__PURE__ */ new WeakMap();
+function scopedStaticString(node, sourceCode) {
+  let value = unwrapExpression(node);
+  if (value.type !== import_utils29.AST_NODE_TYPES.Identifier) return staticString(value);
+  let values = SCOPED_STRING_VALUES.get(sourceCode);
+  if (values === void 0) {
+    values = /* @__PURE__ */ new WeakMap();
+    SCOPED_STRING_VALUES.set(sourceCode, values);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [];
+  let result = null;
+  while (value.type === import_utils29.AST_NODE_TYPES.Identifier) {
+    const binding = import_utils29.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+    if (binding === null || seen.has(binding)) break;
+    if (values.has(binding)) {
+      result = values.get(binding) ?? null;
+      break;
+    }
+    seen.add(binding);
+    pending.push(binding);
+    const definition = binding.defs.length === 1 ? binding.defs[0] : void 0;
+    if (definition?.type !== "Variable" || definition.node.id.type !== import_utils29.AST_NODE_TYPES.Identifier || definition.node.init === null || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) break;
+    value = unwrapExpression(definition.node.init);
+    if (value.type !== import_utils29.AST_NODE_TYPES.Identifier) result = staticString(value);
+  }
+  for (const binding of pending) values.set(binding, result);
+  return result;
+}
+function staticPropertyName(node, sourceCode) {
+  const direct = import_utils29.ASTUtils.getPropertyName(node);
+  if (direct !== null || !node.computed) return direct;
+  const key = node.type === import_utils29.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
+  return key.type === import_utils29.AST_NODE_TYPES.Identifier ? scopedStaticString(key, sourceCode) : null;
+}
 
 // src/rules/no-duplicate-lifecycle-refresh-listeners.ts
 var NO_DUPLICATE_LIFECYCLE_REFRESH_LISTENERS_DOCUMENTATION = {
@@ -6833,31 +6987,26 @@ var NO_JSON_STRINGIFY_ERROR_DOCUMENTATION = {
   rationale: "Native Error details are non-enumerable, so generic JSON serialization discards diagnostic information.",
   remediation: "Serialize explicit error fields or use an error-aware serializer.",
   category: "correctness",
-  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Custom replacers are left to their serializer contract; a catch value is not guaranteed to be an Error."],
+  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Custom replacers and explicit toJSON hooks are left to their serializer contract; a catch value is not guaranteed to be an Error. Member values, including cause, do not inherit the base Error's provenance; even an Error-valued member requires explicit value/dataflow proof outside this rule. Known literal __proto__ initializer chains preserve native hook inheritance and own toJSON precedence; computed __proto__ keys remain data. Unknown prototype expressions, hook values/spreads and deferred hook writes conservatively lose default serializer proof. Explicit writes invalidate constructor provenance except a later, separate top-level statement; deferred functions, loops, and unknown property keys conservatively lose constructor proof. Statically owned global/property writes and native Reflect.set/Reflect.defineProperty/Object.defineProperty/Object.defineProperties calls are tracked. Mutator aliases, replaced Reflect/Object methods, external calls, and runtime-only property names are not resolved; uncertain ordering conservatively loses proof."],
   examples: [
     { id: "explicit-error-message", title: "Narrow an unknown catch value before selecting fields", outcome: "no-match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err instanceof Error ? err.message : String(err) }); }" }], focusPath: "src/report.ts", expectedCount: 0, public: true },
     { id: "stringified-error", title: "Do not stringify an Error object", outcome: "match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err }); }" }], focusPath: "src/report.ts", expectedCount: 1, public: true },
     { id: "shadowed-error-binding", scenarioId: "binding-provenance", title: "Keep native binding provenance", outcome: "match", files: [{ path: "src/error.ts", source: 'function probe(){try{throw {id:1};}catch(err){if(err instanceof Error)return err.message;{const err=new Error("lost");return JSON.stringify(err);}}}\nconsole.log(probe());' }], focusPath: "src/error.ts", expectedCount: 1, public: true },
-    { id: "escaped-fallback-binding", scenarioId: "binding-provenance", title: "Keep native binding provenance", outcome: "no-match", files: [{ path: "src/error.ts", source: "function probe(){try{throw {id:1};}catch(err){if(err instanceof Error)return err.message;return JSON.stringify(\\u0065rr);}}\nconsole.log(probe());" }], focusPath: "src/error.ts", expectedCount: 0, public: true }
+    { id: "escaped-fallback-binding", scenarioId: "binding-provenance", title: "Keep native binding provenance", outcome: "no-match", files: [{ path: "src/error.ts", source: "function probe(){try{throw {id:1};}catch(err){if(err instanceof Error)return err.message;return JSON.stringify(\\u0065rr);}}\nconsole.log(probe());" }], focusPath: "src/error.ts", expectedCount: 0, public: true },
+    { id: "constructor-before-write", scenarioId: "explicit-constructor-write", title: "A later write does not change an already constructed native Error", outcome: "match", files: [{ path: "src/error.js", source: "const value=new Error('lost');Error=class Other{message='kept'};JSON.stringify(value);" }], focusPath: "src/error.js", expectedCount: 1, public: true },
+    { id: "constructor-after-write", scenarioId: "explicit-constructor-write", title: "A replaced constructor does not prove a native Error", outcome: "no-match", files: [{ path: "src/error.js", source: "Error=class Other{message='kept'};const value=new Error();JSON.stringify(value);" }], focusPath: "src/error.js", expectedCount: 0, public: true },
+    { "id": "native-serializer-before-write", "scenarioId": "explicit-serializer-write", "title": "A later write does not change an earlier native serialization", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const result=JSON.stringify(new Error('lost'));JSON.stringify=value=>'kept:'+value.message;" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "native-serializer-after-write", "scenarioId": "explicit-serializer-write", "title": "A replaced serializer owns its error-field contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify=value=>'kept:'+value.message;JSON.stringify(new Error('lost'));" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "static-serializer-key", "scenarioId": "static-property-provenance", "title": "A constant computed serializer still loses native Error details", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const key='stringify';JSON[key](new Error('lost'));" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "static-error-field", "scenarioId": "static-property-provenance", "title": "A constant message field selects the explicit string escape hatch", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "const key='message';const error=new Error('lost');JSON.stringify(error[key]);" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "scalar-cause", "scenarioId": "member-value-provenance", "title": "Native Error cause can be a string value", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "const error=new Error('lost',{cause:'kept'});JSON.stringify(error.cause);" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "whole-error-with-cause", "scenarioId": "member-value-provenance", "title": "Serializing the whole Error still loses its native details", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const error=new Error('lost',{cause:'kept'});JSON.stringify(error);" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "explicit-to-json-hook", "scenarioId": "custom-serializer-contract", "title": "An explicit callable toJSON owns its serialization contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),toJSON(){return {message:'kept'};}});" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "noncallable-to-json", "scenarioId": "custom-serializer-contract", "title": "A noncallable toJSON does not replace native serialization", "outcome": "match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),toJSON:42});" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "literal-prototype-hook", "scenarioId": "native-prototype-serializer", "title": "A literal prototype hook owns the payload serializer contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),__proto__:{toJSON(){return {message:'kept'};}}});" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "computed-prototype-data", "scenarioId": "native-prototype-serializer", "title": "A computed prototype name remains ordinary serialized data", "outcome": "match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),['__proto__']:{toJSON(){return {message:'kept'};}}});" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true }
   ]
 };
-var SAFE_STRING_PROPS = /* @__PURE__ */ new Set(["message", "stack", "name"]);
-var PAYLOAD_PROPS = /* @__PURE__ */ new Set([
-  "data",
-  "status",
-  "statuscode",
-  "statustext",
-  "code",
-  "issues",
-  "details",
-  "body",
-  "payload",
-  "response",
-  "info",
-  "meta",
-  "metadata",
-  "context"
-]);
 var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "AggregateError",
   "Error",
@@ -6868,14 +7017,200 @@ var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "TypeError",
   "URIError"
 ]);
-function identifierIsProvenError(identifier, sourceCode) {
-  const variable = import_utils41.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
-  if (variable === null || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
-  const definition = variable.defs[0];
-  if (definition?.type === "CatchClause") return true;
-  if (definition?.type !== "Variable") return false;
-  const initializer = definition.node.init;
-  return initializer?.type === "NewExpression" && initializer.callee.type === "Identifier" && BUILTIN_ERROR_CONSTRUCTORS.has(initializer.callee.name) && isGlobalIdentifier(initializer.callee.name, sourceCode.getScope(initializer.callee));
+var TRACKED_BUILTINS = /* @__PURE__ */ new Set([...BUILTIN_ERROR_CONSTRUCTORS, "JSON", "JSON.stringify"]);
+function nativeObjectName(expression, sourceCode) {
+  const value = unwrapExpression(expression);
+  const scope = sourceCode.getScope(value);
+  if (value.type === "Identifier" && (value.name === "globalThis" || value.name === "JSON") && isGlobalIdentifier(value.name, scope)) return value.name;
+  if (value.type === "MemberExpression" && nativeObjectName(value.object, sourceCode) === "globalThis" && staticPropertyName(value, sourceCode) === "JSON") return "JSON";
+  return null;
+}
+function globalBuiltinName(expression, sourceCode) {
+  const value = unwrapExpression(expression);
+  const scope = sourceCode.getScope(value);
+  if (value.type === "Identifier") return TRACKED_BUILTINS.has(value.name) && isGlobalIdentifier(value.name, scope) ? value.name : null;
+  if (value.type !== "MemberExpression") return null;
+  const receiver = nativeObjectName(value.object, sourceCode);
+  const name = staticPropertyName(value, sourceCode);
+  if (receiver === "JSON") return name === "stringify" ? "JSON.stringify" : null;
+  return receiver === "globalThis" && name !== null && name !== "JSON.stringify" && TRACKED_BUILTINS.has(name) ? name : null;
+}
+function writePreservesBuiltin(target, sourceCode) {
+  const assignment = target.parent;
+  if (assignment?.type !== "AssignmentExpression" || assignment.left !== target) return false;
+  const name = globalBuiltinName(target, sourceCode);
+  if (name === null) return false;
+  if (assignment.operator === "||=" || assignment.operator === "??=") return true;
+  return (assignment.operator === "=" || assignment.operator === "&&=") && globalBuiltinName(assignment.right, sourceCode) === name;
+}
+function mayBeCallable(value) {
+  return !["Literal", "TemplateLiteral", "ObjectExpression", "ArrayExpression"].includes(value.type);
+}
+var BUILTIN_WRITES = /* @__PURE__ */ new WeakMap();
+function directProgramStatement(node) {
+  let current = node;
+  while (current.parent !== void 0) {
+    if (current.parent.type === "Program") return current;
+    if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "ClassBody", "StaticBlock", "ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement"].includes(current.parent.type)) return null;
+    current = current.parent;
+  }
+  return null;
+}
+function hasUnchangedBuiltin(name, read, sourceCode) {
+  const summary = builtinWrites(sourceCode).get(name);
+  if (summary === void 0) return true;
+  const statement = directProgramStatement(read);
+  return !summary.unknownOrder && statement !== null && statement.range[1] <= summary.earliestStatementStart;
+}
+function builtinWrites(sourceCode) {
+  const cached = BUILTIN_WRITES.get(sourceCode);
+  if (cached !== void 0) return cached;
+  const writes = /* @__PURE__ */ new Map();
+  const record = (name, node) => {
+    const statement = directProgramStatement(node);
+    const existing = writes.get(name);
+    writes.set(name, { earliestStatementStart: Math.min(existing?.earliestStatementStart ?? Infinity, statement?.range[0] ?? Infinity), unknownOrder: (existing?.unknownOrder ?? false) || statement === null });
+  };
+  for (const scope of sourceCode.scopeManager?.scopes ?? []) {
+    for (const reference of scope.references) {
+      const name = reference.identifier.name;
+      if (reference.identifier.type === "Identifier" && reference.isWrite() && TRACKED_BUILTINS.has(name) && (reference.resolved === null || reference.resolved.defs.length === 0) && !writePreservesBuiltin(reference.identifier, sourceCode)) record(name, reference.identifier);
+    }
+  }
+  const propertyReceiver = (expression) => {
+    const native = nativeObjectName(expression, sourceCode);
+    if (native !== null) return native;
+    const value = unwrapExpression(expression);
+    if (value.type === "Identifier") return import_utils41.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+    if (value.type === "MemberExpression" && staticPropertyName(value, sourceCode) === "prototype") {
+      const constructor = globalBuiltinName(value.object, sourceCode);
+      if (constructor !== null && BUILTIN_ERROR_CONSTRUCTORS.has(constructor)) return constructor + ".prototype";
+    }
+    return null;
+  };
+  const propertyWrite = (receiver, name, node) => {
+    if (receiver === "JSON") {
+      if (name === null || name === "stringify") record("JSON.stringify", node);
+    } else if (receiver === "globalThis") {
+      if (name === null) {
+        for (const builtin of TRACKED_BUILTINS) record(builtin, node);
+      } else if (name !== "JSON.stringify" && TRACKED_BUILTINS.has(name)) record(name, node);
+    } else if (name === null || name === "toJSON") record(receiver, node);
+  };
+  const visit = (node) => {
+    if (node.type === "AssignmentExpression") propertyTarget(node.left);
+    else if (node.type === "UpdateExpression") propertyTarget(node.argument);
+    else if (node.type === "ForInStatement" || node.type === "ForOfStatement") propertyTarget(node.left);
+    else if (node.type === "UnaryExpression" && node.operator === "delete") propertyTarget(node.argument);
+    else if (node.type === "CallExpression") mutationCall(node);
+    forEachAstChild(node, sourceCode.visitorKeys, visit);
+  };
+  function propertyTarget(target) {
+    if (target.type === "MemberExpression") {
+      memberPropertyWrite(target);
+      return;
+    }
+    switch (target.type) {
+      case "ObjectPattern":
+        for (const property of target.properties) propertyTarget(property.type === "RestElement" ? property.argument : property.value);
+        return;
+      case "ArrayPattern":
+        for (const element of target.elements) if (element !== null) propertyTarget(element);
+        return;
+      case "AssignmentPattern":
+        propertyTarget(target.left);
+        return;
+      case "RestElement":
+        propertyTarget(target.argument);
+    }
+  }
+  function memberPropertyWrite(target) {
+    const receiver = propertyReceiver(target.object);
+    if (receiver === null || writePreservesBuiltin(target, sourceCode)) return;
+    const name = staticPropertyName(target, sourceCode);
+    if (name === "toJSON") {
+      const assignment = target.parent;
+      if (assignment?.type === "UnaryExpression" && assignment.operator === "delete") return;
+      if (assignment?.type === "AssignmentExpression" && assignment.operator === "=" && !mayBeCallable(assignment.right)) return;
+    }
+    propertyWrite(receiver, name, target);
+  }
+  function mutationCall(node) {
+    const callee = unwrapExpression(node.callee);
+    if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return;
+    const owner = callee.object.name;
+    if (!["Reflect", "Object"].includes(owner) || !isGlobalIdentifier(owner, sourceCode.getScope(callee))) return;
+    const method = staticPropertyName(callee, sourceCode);
+    const [target, key, value, receiver] = node.arguments;
+    if (target === void 0 || target.type === "SpreadElement" || key === void 0) return;
+    const object = propertyReceiver(target);
+    if (object === null) return;
+    switch (method) {
+      case "set":
+        if (owner === "Reflect") reflectSet(object, scopedStaticString(key, sourceCode), value, receiver, node);
+        return;
+      case "defineProperty":
+        descriptorWrite(object, scopedStaticString(key, sourceCode), value, node);
+        return;
+      case "defineProperties":
+        if (owner === "Object") descriptorBatch(object, key, node);
+    }
+  }
+  function reflectSet(object, name, value, receiver, node) {
+    if (receiver !== void 0 && receiver.type !== "SpreadElement" && ["ObjectExpression", "ArrayExpression", "Literal"].includes(unwrapExpression(receiver).type)) return;
+    const builtin = builtinPropertyName(object, name);
+    if (value !== void 0 && value.type !== "SpreadElement" && builtin !== null && globalBuiltinName(value, sourceCode) === builtin) return;
+    if (name === "toJSON" && value !== void 0 && !mayBeCallable(value)) return;
+    propertyWrite(object, name, node);
+  }
+  function descriptorBatch(object, descriptors, node) {
+    if (descriptors.type !== "ObjectExpression") {
+      propertyWrite(object, null, node);
+      return;
+    }
+    for (const property of descriptors.properties) {
+      if (property.type !== "Property") {
+        propertyWrite(object, null, node);
+        continue;
+      }
+      descriptorWrite(object, staticPropertyName(property, sourceCode), property.value, node);
+    }
+  }
+  function descriptorWrite(object, name, descriptor, node) {
+    if (descriptor !== void 0 && !descriptorChangesValue(descriptor, builtinPropertyName(object, name))) return;
+    propertyWrite(object, name, node);
+  }
+  function descriptorChangesValue(descriptor, name) {
+    if (descriptor.type !== "ObjectExpression") return true;
+    return descriptor.properties.some((property) => {
+      if (property.type !== "Property") return true;
+      const key = staticPropertyName(property, sourceCode);
+      if (key === "value" && name === "toJSON" && !mayBeCallable(property.value)) return false;
+      if (key === "value" && property.value.type !== "AssignmentPattern" && property.value.type !== "ArrayPattern" && property.value.type !== "ObjectPattern" && property.value.type !== "TSEmptyBodyFunctionExpression") return name === null || globalBuiltinName(property.value, sourceCode) !== name;
+      return key === null || key === "get" || key === "set";
+    });
+  }
+  function builtinPropertyName(object, name) {
+    return object === "JSON" && name === "stringify" ? "JSON.stringify" : name;
+  }
+  visit(sourceCode.ast);
+  BUILTIN_WRITES.set(sourceCode, writes);
+  return writes;
+}
+function hasDefaultErrorSerialization(expression, call, sourceCode) {
+  let constructor = null;
+  if (expression.type === "Identifier") {
+    const variable = import_utils41.ASTUtils.findVariable(sourceCode.getScope(expression), expression.name);
+    if (variable !== null && !hasUnchangedBuiltin(variable, call, sourceCode)) return false;
+    const definition = variable?.defs[0];
+    const initializer = definition?.type === "Variable" ? definition.node.init : null;
+    if (initializer?.type === "NewExpression" && initializer.callee.type === "Identifier") constructor = initializer.callee.name;
+  } else if (expression.type === "NewExpression" && expression.callee.type === "Identifier") constructor = expression.callee.name;
+  const families = constructor === null ? BUILTIN_ERROR_CONSTRUCTORS : ["Error", constructor];
+  return [...families].every((name) => hasUnchangedBuiltin(name + ".prototype", call, sourceCode));
+}
+function isBuiltinErrorConstructor(identifier, sourceCode) {
+  return sourceCode.scopeManager !== null && BUILTIN_ERROR_CONSTRUCTORS.has(identifier.name) && isGlobalIdentifier(identifier.name, sourceCode.getScope(identifier)) && hasUnchangedBuiltin(identifier.name, identifier, sourceCode);
 }
 function isGlobalIdentifier(name, scope) {
   const binding = import_utils41.ASTUtils.findVariable(scope, name);
@@ -6886,7 +7221,7 @@ function positiveErrorSubject(test, sourceCode) {
 }
 var TYPE_GUARD_PATTERN = /^(is|has)[A-Z]/;
 function instanceofErrorSubject(test, sourceCode) {
-  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.right.type === "Identifier" && test.right.name === "Error" && isGlobalIdentifier("Error", sourceCode.getScope(test.right))) {
+  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.right.type === "Identifier" && test.right.name === "Error" && isBuiltinErrorConstructor(test.right, sourceCode)) {
     return test.left;
   }
   return null;
@@ -6954,16 +7289,17 @@ function sameSubjectBinding(subject, value, sourceCode) {
 function nodeWithin(node, container) {
   return container !== null && node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
 }
-function isJsonStringify(callee) {
+function isJsonStringify(callee, sourceCode) {
   if (callee.type !== "MemberExpression") return false;
   const receiver = unwrapExpression(callee.object);
-  return callee.type === "MemberExpression" && receiver.type === "Identifier" && receiver.name === "JSON" && import_utils41.ASTUtils.getPropertyName(callee) === "stringify";
+  return callee.type === "MemberExpression" && receiver.type === "Identifier" && receiver.name === "JSON" && staticPropertyName(callee, sourceCode) === "stringify";
 }
-function directLiteralValues(argument) {
+function directLiteralValues(argument, sourceCode) {
   argument = unwrapExpression(argument);
   if (argument.type === "ObjectExpression") {
+    if (literalHasSerializer(argument, sourceCode)) return [];
     return argument.properties.flatMap((property) => {
-      if (property.type !== "Property" || import_utils41.ASTUtils.getPropertyName(property) === null) return [];
+      if (property.type !== "Property" || staticPropertyName(property, sourceCode) === null) return [];
       const value = property.value;
       if (value.type === "AssignmentPattern" || value.type === "ArrayPattern" || value.type === "ObjectPattern" || value.type === "TSEmptyBodyFunctionExpression") {
         return [];
@@ -6978,6 +7314,20 @@ function directLiteralValues(argument) {
   }
   return argument.type === "SpreadElement" ? [] : [argument];
 }
+function literalHasSerializer(argument, sourceCode) {
+  for (const property of argument.properties.toReversed()) {
+    if (property.type !== "Property") return true;
+    const key = staticPropertyName(property, sourceCode);
+    if (key === null) return true;
+    if (key === "toJSON") return mayBeCallable(property.value);
+  }
+  for (const property of argument.properties) {
+    if (property.type !== "Property" || property.computed || property.method || property.shorthand || property.kind !== "init" || staticPropertyName(property, sourceCode) !== "__proto__") continue;
+    const prototype = property.value;
+    return prototype.type === "ObjectExpression" ? literalHasSerializer(prototype, sourceCode) : prototype.type !== "Literal" || "regex" in prototype && prototype.regex !== void 0;
+  }
+  return false;
+}
 function expressionSuggestsError(expression, sourceCode) {
   expression = unwrapExpression(expression);
   const unwrappedExpressionCallee = expression.type === "CallExpression" || expression.type === "NewExpression" ? unwrapExpression(expression.callee) : null;
@@ -6985,23 +7335,19 @@ function expressionSuggestsError(expression, sourceCode) {
     return identifierIsProvenError(expression, sourceCode);
   }
   if (expression.type === "NewExpression" && unwrappedExpressionCallee?.type === "Identifier") {
-    return BUILTIN_ERROR_CONSTRUCTORS.has(unwrappedExpressionCallee.name) && isGlobalIdentifier(unwrappedExpressionCallee.name, sourceCode.getScope(unwrappedExpressionCallee));
-  }
-  return expression.type === "MemberExpression" && memberSuggestsError(expression, sourceCode);
-}
-function memberSuggestsError(member, sourceCode) {
-  const propName2 = import_utils41.ASTUtils.getPropertyName(member);
-  const base = member.object;
-  const baseSuggestsError = base.type === "Identifier" && identifierIsProvenError(base, sourceCode);
-  if (baseSuggestsError) {
-    if (propName2 === null) {
-      return true;
-    }
-    const lowered = propName2.toLowerCase();
-    return !SAFE_STRING_PROPS.has(lowered) && !PAYLOAD_PROPS.has(lowered);
+    return isBuiltinErrorConstructor(unwrappedExpressionCallee, sourceCode);
   }
   return false;
 }
+function identifierIsProvenError(identifier, sourceCode) {
+  const variable = import_utils41.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+  if (variable === null || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
+  const definition = variable.defs[0];
+  if (definition?.type === "CatchClause") return true;
+  if (definition?.type !== "Variable") return false;
+  const initializer = definition.node.init;
+  return initializer?.type === "NewExpression" && initializer.callee.type === "Identifier" && isBuiltinErrorConstructor(initializer.callee, sourceCode);
+}
 var no_json_stringify_error_default = createRule({
   name: "no-json-stringify-error",
   documentation: NO_JSON_STRINGIFY_ERROR_DOCUMENTATION,
@@ -7020,7 +7366,7 @@ var no_json_stringify_error_default = createRule({
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (!isJsonStringify(unwrappedNodeCallee)) {
+        if (!isJsonStringify(unwrappedNodeCallee, context.sourceCode)) {
           return;
         }
         const firstArg = node.arguments[0];
@@ -7028,11 +7374,11 @@ var no_json_stringify_error_default = createRule({
           return;
         }
         const scope = context.sourceCode.getScope(firstArg);
-        if (!isGlobalIdentifier("JSON", scope)) return;
+        if (!isGlobalIdentifier("JSON", scope) || !hasUnchangedBuiltin("JSON", node, context.sourceCode) || !hasUnchangedBuiltin("JSON.stringify", node, context.sourceCode)) return;
         const replacer = node.arguments[1] === void 0 ? void 0 : unwrapExpression(node.arguments[1]);
         if (replacer !== void 0 && !(replacer.type === "Literal" && replacer.value === null) && !(replacer.type === "Identifier" && replacer.name === "undefined" && isGlobalIdentifier("undefined", scope))) return;
-        const unsafeValue = directLiteralValues(firstArg).find(
-          (value) => expressionSuggestsError(value, context.sourceCode) && !isGuardedByInstanceofError(node, value, context.sourceCode) && !isNarrowedByEarlyReturn(node, value, context.sourceCode)
+        const unsafeValue = directLiteralValues(firstArg, context.sourceCode).find(
+          (value) => expressionSuggestsError(value, context.sourceCode) && hasDefaultErrorSerialization(unwrapExpression(value), node, context.sourceCode) && !isGuardedByInstanceofError(node, value, context.sourceCode) && !isNarrowedByEarlyReturn(node, value, context.sourceCode)
         );
         if (unsafeValue === void 0) {
           return;
@@ -11506,10 +11852,12 @@ var NO_SILENT_PROMISE_CATCH_DOCUMENTATION = {
   rationale: "A swallowed rejection hides failures and gives callers an indistinguishable fallback value.",
   remediation: "Log, rethrow, or explicitly recover from the rejection; explain intentional teardown suppression.",
   category: "correctness",
-  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded. Other untyped catch-like APIs are not proven to be Promises."],
+  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded. Other untyped catch-like APIs are not proven to be Promises.", "Computed methods resolve literal syntax and stable local string aliases in lexical scope. Function-derived, object-derived and mutated computed keys remain unproven."],
   examples: [
     { id: "reported-rejection", title: "Report the rejection", outcome: "no-match", files: [{ path: "src/load.ts", source: "load().catch((error) => logger.error({ error }, 'load failed'));" }], focusPath: "src/load.ts", expectedCount: 0, public: true },
-    { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true }
+    { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true },
+    { id: "stable-computed-catch", scenarioId: "computed-method-scope", title: "Report a rejection through a stable computed method", outcome: "match", files: [{ path: "src/load.ts", source: "const method = 'catch'; Promise.reject(new Error('lost'))[method](() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true },
+    { id: "stable-computed-body-parser", scenarioId: "computed-method-scope", title: "Preserve a recognized optional body parse fallback", outcome: "no-match", files: [{ path: "src/load.ts", source: "const method = 'json'; new Response('')[method]().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 0, public: true }
   ]
 };
 var BODY_PARSE_METHODS = /* @__PURE__ */ new Set([
@@ -11557,9 +11905,11 @@ var ZOD_CHAIN_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-function isBodyParseCall(node) {
+function isBodyParseCall(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) !== null && BODY_PARSE_METHODS.has(import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "");
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || node.arguments.length !== 0 || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
+  const method = staticPropertyName(unwrappedNodeCallee, sourceCode);
+  return method !== null && BODY_PARSE_METHODS.has(method);
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -11573,13 +11923,15 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
-function isTeardownCall(node) {
+function isTeardownCall(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) !== null && TEARDOWN_METHODS.has(import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "");
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
+  const method = staticPropertyName(unwrappedNodeCallee, sourceCode);
+  return method !== null && TEARDOWN_METHODS.has(method);
 }
-function isCancelledWebShare(node) {
+function isCancelledWebShare(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && unwrappedNodeCallee.object.type === import_utils68.AST_NODE_TYPES.Identifier && unwrappedNodeCallee.object.name === "navigator" && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === "share";
+  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && unwrappedNodeCallee.object.type === import_utils68.AST_NODE_TYPES.Identifier && unwrappedNodeCallee.object.name === "navigator" && staticPropertyName(unwrappedNodeCallee, sourceCode) === "share";
 }
 function isSilentHandler(handler) {
   const body2 = handler.body;
@@ -11643,9 +11995,9 @@ var no_silent_promise_catch_default = createRule({
         const [definition] = binding.defs;
         return binding.defs.length === 1 && definition?.node.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && definition.node.init !== null && isZodSchema(definition.node.init, seen);
       }
-      if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression || import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === null) return false;
+      if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
       const { object } = unwrappedNodeCallee;
-      const method = import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee);
+      const method = staticPropertyName(unwrappedNodeCallee, context.sourceCode);
       if (object.type === import_utils68.AST_NODE_TYPES.Identifier && method !== null && ZOD_CONSTRUCTORS.has(method)) {
         const binding = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
         if (binding?.defs.some((definition) => {
@@ -11674,23 +12026,23 @@ var no_silent_promise_catch_default = createRule({
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === null) {
+        if (unwrappedNodeCallee.type !== import_utils68.AST_NODE_TYPES.MemberExpression) {
           return;
         }
-        const method = import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "";
+        const method = staticPropertyName(unwrappedNodeCallee, context.sourceCode);
         const handlerIndex = method === "catch" ? 0 : method === "then" ? 1 : null;
         if (handlerIndex === null) return;
         if (method === "catch" && isZodSchema(unwrappedNodeCallee.object)) return;
-        if (isBodyParseCall(unwrappedNodeCallee.object)) {
+        if (isBodyParseCall(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (isTeardownCall(unwrappedNodeCallee.object)) {
+        if (isTeardownCall(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (isCancelledWebShare(unwrappedNodeCallee.object)) {
+        if (isCancelledWebShare(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (node.parent.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.parent.object === node && import_utils68.ASTUtils.getPropertyName(node.parent) === "then") {
+        if (node.parent.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.parent.object === node && staticPropertyName(node.parent, context.sourceCode) === "then") {
           return;
         }
         const expectedArguments = method === "catch" ? 1 : 2;
@@ -21008,8 +21360,112 @@ function staticFieldName(key) {
   return key.type === import_utils115.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils115.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
 }
 
-// src/rules/prefer-zod-parse-output-type.ts
+// src/rules/named-child-schema-type.ts
 var import_utils116 = require("@typescript-eslint/utils");
+var UNRESOLVED_TYPE_NODES = /* @__PURE__ */ new Set([
+  import_utils116.AST_NODE_TYPES.TSTypeQuery,
+  import_utils116.AST_NODE_TYPES.TSImportType,
+  import_utils116.AST_NODE_TYPES.TSTypeParameter,
+  import_utils116.AST_NODE_TYPES.TSAnyKeyword,
+  import_utils116.AST_NODE_TYPES.TSUnknownKeyword
+]);
+var NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION = {
+  defaultLevel: "warning",
+  summary: "Reference a named Zod record child's complete schema type instead of repeating its explicit annotation.",
+  rationale: "Repeating a child schema's generic contract creates a second maintained declaration even though the record already uses that child at runtime.",
+  remediation: "Replace only the matching record type argument with `typeof ChildSchema`; retain the outer annotation required by isolatedDeclarations and every runtime schema operation.",
+  category: "maintainability",
+  autofix: "none",
+  limitations: [
+    "Only direct module-level const z.record calls with two arguments, a ZodRecord annotation, and an earlier local const child with a complete explicit Zod type are inspected.",
+    "The entire generic child annotation must match token for token; input/output, defaults, transforms, readonly modifiers and brands are never compared by output shape alone.",
+    "Bare leaf types, broad ZodType constraints, type queries, imported or unqualified type references, annotation cycles, comments on the repeated argument, mutable bindings and generated files are excluded.",
+    "Import aliases and namespace imports resolve through scope bindings. Independent public contract pins require review; this warning does not remove annotations or change runtime validation."
+  ],
+  examples: [
+    { id: "named-child", title: "Reference the named child contract", outcome: "no-match", files: [{ path: "src/record.ts", source: 'import { z } from "zod"; const KeySchema: z.ZodEnum<{ a: "a"; b: "b" }> = z.enum(["a", "b"]); export const RecordSchema: z.ZodRecord<typeof KeySchema, z.ZodString> = z.record(KeySchema, z.string());' }], focusPath: "src/record.ts", expectedCount: 0, public: true },
+    { id: "copied-child", title: "Do not repeat the complete child annotation", outcome: "match", files: [{ path: "src/record.ts", source: 'import { z } from "zod"; const KeySchema: z.ZodEnum<{ a: "a"; b: "b" }> = z.enum(["a", "b"]); export const RecordSchema: z.ZodRecord<z.ZodEnum<{ a: "a"; b: "b" }>, z.ZodString> = z.record(KeySchema, z.string());' }], focusPath: "src/record.ts", expectedCount: 1, public: true }
+  ]
+};
+function isModuleConst(node) {
+  if (node.parent.kind !== "const" || node.id.type !== import_utils116.AST_NODE_TYPES.Identifier) return false;
+  const parent = node.parent.parent;
+  return parent.type === import_utils116.AST_NODE_TYPES.Program || parent.type === import_utils116.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent.type === import_utils116.AST_NODE_TYPES.Program;
+}
+var named_child_schema_type_default = createRule({
+  name: "named-child-schema-type",
+  documentation: NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION.summary },
+    schema: [],
+    messages: { namedChildType: "Use `typeof {{name}}` for this exact child contract; keep the outer schema annotation and runtime operations." }
+  },
+  defaultOptions: [],
+  create(context) {
+    const source = context.sourceCode;
+    if (isGeneratedFile(context.filename, source.text)) return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    const bindingOf = (node) => import_utils116.ASTUtils.findVariable(source.getScope(node), node.name);
+    function namespaceOf(type) {
+      if (type.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || type.typeName.left.type !== import_utils116.AST_NODE_TYPES.Identifier) return null;
+      const binding = bindingOf(type.typeName.left);
+      return binding !== null && namespaces.has(binding) ? binding : null;
+    }
+    function closedType(node, namespace) {
+      if (UNRESOLVED_TYPE_NODES.has(node.type)) return false;
+      if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && namespaceOf(node) !== namespace) return false;
+      return !forEachOwnAstChild(node, (child) => !closedType(child, namespace));
+    }
+    function inspectChild(argument, repeated, namespace, parent) {
+      if (argument.type !== import_utils116.AST_NODE_TYPES.Identifier || repeated.type !== import_utils116.AST_NODE_TYPES.TSTypeReference || repeated.typeArguments === void 0) return;
+      if (repeated.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || /^(?:ZodType|ZodSchema|ZodTypeAny)$/u.test(repeated.typeName.right.name)) return;
+      const variable = bindingOf(argument);
+      const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
+      if (definition?.type !== "Variable" || !isModuleConst(definition.node)) return;
+      const child = definition.node;
+      if (child.id.type !== import_utils116.AST_NODE_TYPES.Identifier || child.init === null || child.range[0] >= parent.range[0]) return;
+      const annotation = child.id.typeAnnotation?.typeAnnotation;
+      if (annotation === void 0 || factoryNamespace(child.init) !== namespace || !closedType(annotation, namespace)) return;
+      if (source.getCommentsInside(repeated).length > 0 || source.getCommentsBefore(repeated).length > 0) return;
+      const expected = source.getTokens(annotation);
+      const actual = source.getTokens(repeated);
+      if (expected.length !== actual.length || expected.some((token, index) => token.type !== actual[index]?.type || token.value !== actual[index]?.value)) return;
+      context.report({ node: repeated, messageId: "namedChildType", data: { name: argument.name } });
+    }
+    function factoryNamespace(expression) {
+      if (expression.type !== import_utils116.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression) return null;
+      const object = expression.callee.object;
+      return object.type === import_utils116.AST_NODE_TYPES.Identifier ? bindingOf(object) : factoryNamespace(object);
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type" || !isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== import_utils116.AST_NODE_TYPES.ImportNamespaceSpecifier && (specifier.type !== import_utils116.AST_NODE_TYPES.ImportSpecifier || specifier.importKind === "type" || importSpecifierName(specifier) !== "z")) continue;
+          const binding = bindingOf(specifier.local);
+          if (binding !== null) namespaces.add(binding);
+        }
+      },
+      VariableDeclarator(node) {
+        if (!isModuleConst(node) || node.id.type !== import_utils116.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils116.AST_NODE_TYPES.CallExpression) return;
+        const call = node.init;
+        if (call.arguments.length !== 2 || call.callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || call.callee.object.type !== import_utils116.AST_NODE_TYPES.Identifier || import_utils116.ASTUtils.getPropertyName(call.callee) !== "record") return;
+        const annotation = node.id.typeAnnotation?.typeAnnotation;
+        if (annotation?.type !== import_utils116.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils116.AST_NODE_TYPES.TSQualifiedName || annotation.typeName.right.name !== "ZodRecord") return;
+        const namespace = namespaceOf(annotation);
+        if (namespace === null || bindingOf(call.callee.object) !== namespace || annotation.typeArguments?.params.length !== 2) return;
+        for (const [index, argument] of call.arguments.entries()) {
+          const repeated = annotation.typeArguments.params[index];
+          if (repeated !== void 0) inspectChild(argument, repeated, namespace, node);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-zod-parse-output-type.ts
+var import_utils117 = require("@typescript-eslint/utils");
 var import_typescript7 = __toESM(require("typescript"), 1);
 var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
   summary: "Derive a function's return contract from the local Zod schema whose parsed output it returns.",
@@ -21065,22 +21521,22 @@ var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
 };
 function isModuleLevelConst2(node) {
   const declaration = node.parent;
-  if (declaration.type !== import_utils116.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== import_utils117.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === import_utils116.AST_NODE_TYPES.Program || container.type === import_utils116.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils116.AST_NODE_TYPES.Program;
+  return container.type === import_utils117.AST_NODE_TYPES.Program || container.type === import_utils117.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils117.AST_NODE_TYPES.Program;
 }
 function isLocalZodObjectSchema(node, namespaces) {
   let current = node;
-  while (current.type === import_utils116.AST_NODE_TYPES.CallExpression) {
+  while (current.type === import_utils117.AST_NODE_TYPES.CallExpression) {
     const callee = unwrapExpression(current.callee);
-    const calleeReceiver = callee.type === import_utils116.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-    if (callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || import_utils116.ASTUtils.getPropertyName(callee) === null) {
+    const calleeReceiver = callee.type === import_utils117.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+    if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || import_utils117.ASTUtils.getPropertyName(callee) === null) {
       return false;
     }
-    if (calleeReceiver.type === import_utils116.AST_NODE_TYPES.Identifier) {
-      return namespaces.has(calleeReceiver.name) && ((import_utils116.ASTUtils.getPropertyName(callee) ?? "") === "object" || (import_utils116.ASTUtils.getPropertyName(callee) ?? "") === "strictObject");
+    if (calleeReceiver.type === import_utils117.AST_NODE_TYPES.Identifier) {
+      return namespaces.has(calleeReceiver.name) && ((import_utils117.ASTUtils.getPropertyName(callee) ?? "") === "object" || (import_utils117.ASTUtils.getPropertyName(callee) ?? "") === "strictObject");
     }
     current = calleeReceiver;
   }
@@ -21088,11 +21544,11 @@ function isLocalZodObjectSchema(node, namespaces) {
 }
 function zodParseCall(node) {
   const callee = unwrapExpression(node.callee);
-  const calleeReceiver = callee.type === import_utils116.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-  if (callee.type !== import_utils116.AST_NODE_TYPES.MemberExpression || calleeReceiver.type !== import_utils116.AST_NODE_TYPES.Identifier || import_utils116.ASTUtils.getPropertyName(callee) === null) {
+  const calleeReceiver = callee.type === import_utils117.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+  if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || calleeReceiver.type !== import_utils117.AST_NODE_TYPES.Identifier || import_utils117.ASTUtils.getPropertyName(callee) === null) {
     return null;
   }
-  const method = import_utils116.ASTUtils.getPropertyName(callee);
+  const method = import_utils117.ASTUtils.getPropertyName(callee);
   if (method !== "parse" && method !== "safeParse") return null;
   return {
     call: node,
@@ -21106,7 +21562,7 @@ function returnedOutputCandidate(parsed, output) {
   const annotation = owner?.returnType?.typeAnnotation;
   if (annotation === void 0) return null;
   const typeReference = returnContractReference(annotation);
-  if (typeReference === null || typeReference.typeName.type !== import_utils116.AST_NODE_TYPES.Identifier) {
+  if (typeReference === null || typeReference.typeName.type !== import_utils117.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return {
@@ -21123,7 +21579,7 @@ function directParseReturnCandidate(node) {
   return parsed?.method === "parse" ? returnedOutputCandidate(parsed, node) : null;
 }
 function localParseReturnCandidates(node, sourceCode) {
-  if (node.id.type !== import_utils116.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils116.AST_NODE_TYPES.CallExpression || node.parent.type !== import_utils116.AST_NODE_TYPES.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
+  if (node.id.type !== import_utils117.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils117.AST_NODE_TYPES.CallExpression || node.parent.type !== import_utils117.AST_NODE_TYPES.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
     return [];
   }
   const parsed = zodParseCall(node.init);
@@ -21134,7 +21590,7 @@ function localParseReturnCandidates(node, sourceCode) {
   for (const reference of variable.references) {
     const identifier = reference.identifier;
     const parent = identifier.parent;
-    const output = parsed.method === "parse" ? identifier : parent.type === import_utils116.AST_NODE_TYPES.MemberExpression && parent.object === identifier && import_utils116.ASTUtils.getPropertyName(parent) !== null && (import_utils116.ASTUtils.getPropertyName(parent) ?? "") === "data" ? parent : null;
+    const output = parsed.method === "parse" ? identifier : parent.type === import_utils117.AST_NODE_TYPES.MemberExpression && parent.object === identifier && import_utils117.ASTUtils.getPropertyName(parent) !== null && (import_utils117.ASTUtils.getPropertyName(parent) ?? "") === "data" ? parent : null;
     if (output === null) continue;
     const candidate2 = returnedOutputCandidate(parsed, output);
     if (candidate2 !== null) candidates.push(candidate2);
@@ -21145,17 +21601,17 @@ function directReturnOwner(node) {
   let current = node;
   while (current.parent !== void 0) {
     const parent = current.parent;
-    if (parent.type === import_utils116.AST_NODE_TYPES.ReturnStatement) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ReturnStatement) {
       return parent.argument === current ? enclosingFunction4(parent) : null;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.ArrowFunctionExpression && parent.expression && parent.body === current) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression && parent.expression && parent.body === current) {
       return parent;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.AwaitExpression && parent.argument === current) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.AwaitExpression && parent.argument === current) {
       current = parent;
       continue;
     }
-    if (parent.type === import_utils116.AST_NODE_TYPES.ConditionalExpression) {
+    if (parent.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
       const parsedWhenTrue = parent.consequent === current && isNullishExpression(parent.alternate);
       const parsedWhenFalse = parent.alternate === current && isNullishExpression(parent.consequent);
       if (parsedWhenTrue || parsedWhenFalse) {
@@ -21168,12 +21624,12 @@ function directReturnOwner(node) {
   return null;
 }
 function isNullishExpression(node) {
-  return node.type === import_utils116.AST_NODE_TYPES.Literal && node.value === null || node.type === import_utils116.AST_NODE_TYPES.Identifier && node.name === "undefined";
+  return node.type === import_utils117.AST_NODE_TYPES.Literal && node.value === null || node.type === import_utils117.AST_NODE_TYPES.Identifier && node.name === "undefined";
 }
 function enclosingFunction4(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils116.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils116.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils116.AST_NODE_TYPES.FunctionExpression) {
+    if (current.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils117.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils117.AST_NODE_TYPES.FunctionExpression) {
       return current;
     }
     current = current.parent;
@@ -21181,45 +21637,45 @@ function enclosingFunction4(node) {
   return null;
 }
 function returnContractReference(node) {
-  if (node.type === import_utils116.AST_NODE_TYPES.TSUnionType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSUnionType) {
     const substantive = node.types.filter(
-      (member) => member.type !== import_utils116.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils116.AST_NODE_TYPES.TSUndefinedKeyword
+      (member) => member.type !== import_utils117.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils117.AST_NODE_TYPES.TSUndefinedKeyword
     );
     const [only] = substantive;
     return substantive.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier && node.typeName.name === "Promise") {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier && node.typeName.name === "Promise") {
     const parameters = node.typeArguments?.params ?? [];
     const [only] = parameters;
     return parameters.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  return node.type === import_utils116.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
+  return node.type === import_utils117.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
 }
 function recordZodNamespaces(node, namespaces) {
   for (const statement of node.body) {
-    if (statement.type !== import_utils116.AST_NODE_TYPES.ImportDeclaration || !isZodModule(statement.source.value)) {
+    if (statement.type !== import_utils117.AST_NODE_TYPES.ImportDeclaration || !isZodModule(statement.source.value)) {
       continue;
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.type === import_utils116.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils116.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils116.AST_NODE_TYPES.ImportSpecifier && importSpecifierName(specifier) === "z") {
+      if (specifier.type === import_utils117.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils117.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils117.AST_NODE_TYPES.ImportSpecifier && importSpecifierName(specifier) === "z") {
         namespaces.add(specifier.local.name);
       }
     }
   }
 }
 function collectConstrainedNames(node, names) {
-  if (node.type === import_utils116.AST_NODE_TYPES.TSTypeReference) {
-    if (node.typeName.type === import_utils116.AST_NODE_TYPES.Identifier) names.add(node.typeName.name);
+  if (node.type === import_utils117.AST_NODE_TYPES.TSTypeReference) {
+    if (node.typeName.type === import_utils117.AST_NODE_TYPES.Identifier) names.add(node.typeName.name);
     for (const argument of node.typeArguments?.params ?? []) {
       collectConstrainedNames(argument, names);
     }
     return;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSArrayType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSArrayType) {
     collectConstrainedNames(node.elementType, names);
     return;
   }
-  if (node.type === import_utils116.AST_NODE_TYPES.TSUnionType || node.type === import_utils116.AST_NODE_TYPES.TSIntersectionType) {
+  if (node.type === import_utils117.AST_NODE_TYPES.TSUnionType || node.type === import_utils117.AST_NODE_TYPES.TSIntersectionType) {
     for (const member of node.types) collectConstrainedNames(member, names);
   }
 }
@@ -21253,7 +21709,7 @@ function reportCandidates(context, services, schemas, candidates, zodNamespaces,
     if (constrained) return;
     if (declaration.getSourceFile() === tsSchema.getSourceFile()) {
       const estreeDeclaration = services.tsNodeToESTreeNodeMap.get(declaration);
-      if ((estreeDeclaration.type === import_utils116.AST_NODE_TYPES.TSInterfaceDeclaration || estreeDeclaration.type === import_utils116.AST_NODE_TYPES.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
+      if ((estreeDeclaration.type === import_utils117.AST_NODE_TYPES.TSInterfaceDeclaration || estreeDeclaration.type === import_utils117.AST_NODE_TYPES.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
         constrained,
         declaration: estreeDeclaration,
         initializer: schema.initializer,
@@ -21343,7 +21799,7 @@ var prefer_zod_parse_output_type_default = createRule({
     }
     let services;
     try {
-      services = import_utils116.ESLintUtils.getParserServices(context);
+      services = import_utils117.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -21358,7 +21814,7 @@ var prefer_zod_parse_output_type_default = createRule({
         recordZodNamespaces(node, namespaces);
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils116.AST_NODE_TYPES.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
+        if (node.id.type === import_utils117.AST_NODE_TYPES.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
           schemas.push({ identifier: node.id, initializer: node.init, name: node.id.name });
         }
         candidates.push(...localParseReturnCandidates(node, context.sourceCode));
@@ -21368,13 +21824,13 @@ var prefer_zod_parse_output_type_default = createRule({
         if (candidate2 !== null) candidates.push(candidate2);
       },
       "MemberExpression"(node) {
-        if (node.object.type === import_utils116.AST_NODE_TYPES.Identifier && node.property.type === import_utils116.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+        if (node.object.type === import_utils117.AST_NODE_TYPES.Identifier && node.property.type === import_utils117.AST_NODE_TYPES.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemas.add(node.object.name);
         }
       },
       TSTypeReference(node) {
         const { typeName } = node;
-        const name = typeName.type === import_utils116.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils116.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils116.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const name = typeName.type === import_utils117.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils117.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils117.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (name === null || !isPreferZodInferTypeConstraintName(name)) return;
         for (const argument of node.typeArguments?.params ?? []) {
           collectConstrainedNames(argument, constrainedTypeNames);
@@ -21396,7 +21852,7 @@ var prefer_zod_parse_output_type_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils117 = require("@typescript-eslint/utils");
+var import_utils118 = require("@typescript-eslint/utils");
 var import_typescript8 = __toESM(require("typescript"), 1);
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
@@ -21410,14 +21866,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils117.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils117.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils118.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils117.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils117.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils118.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils117.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils118.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -21433,7 +21889,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils117.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils118.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -21487,7 +21943,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils117.ESLintUtils.getParserServices(context);
+      services = import_utils118.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -21514,7 +21970,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils118 = require("@typescript-eslint/utils");
+var import_utils119 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an explicit abort signal on locally analyzable global fetch calls.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -21541,18 +21997,18 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init, resolvesToGlobal) {
-  if (init.type !== import_utils118.AST_NODE_TYPES.ObjectExpression) return false;
+  if (init.type !== import_utils119.AST_NODE_TYPES.ObjectExpression) return false;
   let lacksSignal = true;
   for (const prop of init.properties) {
-    if (prop.type === import_utils118.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils119.AST_NODE_TYPES.SpreadElement) {
       lacksSignal = false;
       continue;
     }
-    const isSignal = !prop.computed && prop.key.type === import_utils118.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils118.AST_NODE_TYPES.Literal && prop.key.value === "signal";
+    const isSignal = !prop.computed && prop.key.type === import_utils119.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils119.AST_NODE_TYPES.Literal && prop.key.value === "signal";
     if (isSignal) {
       const value = prop.value;
-      lacksSignal = prop.kind === "init" && !prop.method && (value.type === import_utils118.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils118.AST_NODE_TYPES.Identifier && value.name === "undefined" && resolvesToGlobal(value) || value.type === import_utils118.AST_NODE_TYPES.UnaryExpression && value.operator === "void" && value.argument.type === import_utils118.AST_NODE_TYPES.Literal && value.argument.value === 0);
-    } else if (prop.computed && prop.key.type !== import_utils118.AST_NODE_TYPES.Literal) {
+      lacksSignal = prop.kind === "init" && !prop.method && (value.type === import_utils119.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils119.AST_NODE_TYPES.Identifier && value.name === "undefined" && resolvesToGlobal(value) || value.type === import_utils119.AST_NODE_TYPES.UnaryExpression && value.operator === "void" && value.argument.type === import_utils119.AST_NODE_TYPES.Literal && value.argument.value === 0);
+    } else if (prop.computed && prop.key.type !== import_utils119.AST_NODE_TYPES.Literal) {
       lacksSignal = false;
     }
   }
@@ -21560,7 +22016,7 @@ function initProvablyLacksSignal(init, resolvesToGlobal) {
 }
 function isInlineUrl(node, resolvesToGlobal) {
   node = unwrapExpression(node);
-  return node.type === import_utils118.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils118.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils118.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils118.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils119.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils119.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils119.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -21598,30 +22054,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils118.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils119.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils118.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils119.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils118.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils118.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils118.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils119.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils119.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils119.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils118.ASTUtils.findVariable(
+      const variable = import_utils119.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils118.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init, resolvesToGlobal)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils119.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init, resolvesToGlobal)) {
         return false;
       }
       for (const reference of variable.references) {
         const ref = reference.identifier;
         if (ref === identifier || ref === definition.name) continue;
         const member = ref.parent;
-        if (member.type !== import_utils118.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils118.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils118.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils119.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils119.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils119.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -21629,13 +22085,13 @@ var require_fetch_timeout_default = createRule({
     }
     function isForwardedRequest(argument) {
       let value = argument;
-      if (value.type === import_utils118.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils118.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
+      if (value.type === import_utils119.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name);
         const definition = binding?.defs.length === 1 ? binding.defs[0] : void 0;
         if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || binding?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         value = definition.node.init;
       }
-      return value.type === import_utils118.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils118.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
+      return value.type === import_utils119.AST_NODE_TYPES.NewExpression && value.callee.type === import_utils119.AST_NODE_TYPES.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
     }
     return {
       CallExpression(node) {
@@ -21647,7 +22103,7 @@ var require_fetch_timeout_default = createRule({
         if (first !== void 0 && (node.arguments.length === 1 && !isInlineUrl(first, resolvesToGlobal) || isForwardedRequest(first))) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init, resolvesToGlobal) || init.type === import_utils118.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init, resolvesToGlobal) || init.type === import_utils119.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -21656,7 +22112,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-var import_utils119 = require("@typescript-eslint/utils");
+var import_utils120 = require("@typescript-eslint/utils");
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Require exported concrete classes with public behavior to declare a contract.",
@@ -21703,23 +22159,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === import_utils119.AST_NODE_TYPES.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils119.AST_NODE_TYPES.PrivateIdentifier;
+    if (member.type === import_utils120.AST_NODE_TYPES.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils120.AST_NODE_TYPES.PrivateIdentifier;
     }
-    if (member.type !== import_utils119.AST_NODE_TYPES.PropertyDefinition || member.static)
+    if (member.type !== import_utils120.AST_NODE_TYPES.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) return false;
-    return member.value?.type === import_utils119.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils119.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils119.AST_NODE_TYPES.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils120.AST_NODE_TYPES.PrivateIdentifier) return false;
+    return member.value?.type === import_utils120.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils120.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils120.AST_NODE_TYPES.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === import_utils119.AST_NODE_TYPES.ClassDeclaration) {
+  const declaration = statement.type === import_utils120.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === import_utils120.AST_NODE_TYPES.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration?.type !== import_utils120.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils119.AST_NODE_TYPES.Identifier && item.init?.type === import_utils119.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === import_utils120.AST_NODE_TYPES.Identifier && item.init?.type === import_utils120.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -21753,7 +22209,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = exportedClasses(program, classes);
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils119.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils120.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
           if (declaration.abstract || declaration.implements.length > 0 || extendsLocalAbstractBase || !hasPublicInstanceBehavior(declaration)) continue;
           context.report({
             node: declaration.id ?? declaration,
@@ -21768,7 +22224,7 @@ var require_interface_for_exported_class_default = createRule({
 function exportedClasses(program, classes) {
   const exported = /* @__PURE__ */ new Map();
   function collectExportedClass(statement) {
-    if (statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration) {
+    if (statement.type === import_utils120.AST_NODE_TYPES.ExportNamedDeclaration) {
       for (const binding of classBindings(statement)) {
         exported.set(binding.declaration, binding.name);
       }
@@ -21776,13 +22232,13 @@ function exportedClasses(program, classes) {
       collectClassSpecifiers(statement);
       return;
     }
-    if (statement.type !== import_utils119.AST_NODE_TYPES.ExportDefaultDeclaration) return;
-    if (statement.declaration.type === import_utils119.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils119.AST_NODE_TYPES.ClassExpression) {
+    if (statement.type !== import_utils120.AST_NODE_TYPES.ExportDefaultDeclaration) return;
+    if (statement.declaration.type === import_utils120.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils120.AST_NODE_TYPES.ClassExpression) {
       exported.set(
         statement.declaration,
         statement.declaration.id?.name ?? "default"
       );
-    } else if (statement.declaration.type === import_utils119.AST_NODE_TYPES.Identifier) {
+    } else if (statement.declaration.type === import_utils120.AST_NODE_TYPES.Identifier) {
       const candidate2 = classes.get(statement.declaration.name);
       if (candidate2 !== void 0) {
         exported.set(candidate2, statement.declaration.name);
@@ -21794,7 +22250,7 @@ function exportedClasses(program, classes) {
       if (specifier.exportKind === "type") continue;
       const candidate2 = classes.get(specifier.local.name);
       if (candidate2 === void 0) continue;
-      const exportedName = specifier.exported.type === import_utils119.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+      const exportedName = specifier.exported.type === import_utils120.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
       exported.set(candidate2, exportedName);
     }
   }
@@ -21805,7 +22261,7 @@ function exportedClasses(program, classes) {
 }
 
 // src/rules/require-sql-access-class.ts
-var import_utils120 = require("@typescript-eslint/utils");
+var import_utils121 = require("@typescript-eslint/utils");
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -21909,80 +22365,80 @@ function isDatabaseOperation(method, receiver) {
 }
 function databaseReceiver(node) {
   node = unwrapExpression(node);
-  if (node.type === import_utils120.AST_NODE_TYPES.Identifier)
+  if (node.type === import_utils121.AST_NODE_TYPES.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
-  const name = import_utils120.ASTUtils.getPropertyName(node);
+  if (node.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
+  const name = import_utils121.ASTUtils.getPropertyName(node);
   return name === "DB" || name !== null && DATABASE_NAMES.test(name);
 }
 function databaseRootMember(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return null;
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-      if (current.object.type === import_utils120.AST_NODE_TYPES.ThisExpression)
-        return import_utils120.ASTUtils.getPropertyName(current);
+    if (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+      if (current.object.type === import_utils121.AST_NODE_TYPES.ThisExpression)
+        return import_utils121.ASTUtils.getPropertyName(current);
       current = current.object;
       continue;
     }
-    return current.type === import_utils120.AST_NODE_TYPES.Identifier ? current.name : null;
+    return current.type === import_utils121.AST_NODE_TYPES.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-      const name = import_utils120.ASTUtils.getPropertyName(current);
+    if (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+      const name = import_utils121.ASTUtils.getPropertyName(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === import_utils120.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === import_utils121.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils120.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils121.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils120.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
-      const name = import_utils120.ASTUtils.getPropertyName(current.callee);
+    if (current.type === import_utils121.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
+      const name = import_utils121.ASTUtils.getPropertyName(current.callee);
       if (name !== null && BUILDER_METHODS.has(name)) return true;
       current = current.callee.object;
       continue;
     }
-    if (current.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils120.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils120.AST_NODE_TYPES.ClassExpression)
+    if (current.type === import_utils121.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils121.AST_NODE_TYPES.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -21991,25 +22447,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === import_utils120.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === import_utils121.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
   );
   if (constructor === void 0) return injected;
   const parameters = /* @__PURE__ */ new Set();
   for (const parameter of constructor.value.params) {
     for (const name of parameterNames(parameter)) parameters.add(name);
-    if (parameter.type !== import_utils120.AST_NODE_TYPES.TSParameterProperty) continue;
-    const value = parameter.parameter.type === import_utils120.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === import_utils120.AST_NODE_TYPES.Identifier) injected.add(value.name);
+    if (parameter.type !== import_utils121.AST_NODE_TYPES.TSParameterProperty) continue;
+    const value = parameter.parameter.type === import_utils121.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === import_utils121.AST_NODE_TYPES.Identifier) injected.add(value.name);
   }
   const body2 = constructor.value.body;
   if (body2 === null) return injected;
   function collectInjectedMember(statement) {
-    if (statement.type !== import_utils120.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils120.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") return;
+    if (statement.type !== import_utils121.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils121.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") return;
     const { left, right } = statement.expression;
-    if (left.type !== import_utils120.AST_NODE_TYPES.MemberExpression) return;
+    if (left.type !== import_utils121.AST_NODE_TYPES.MemberExpression) return;
     const target = thisRootMember(left);
     if (target === null) return;
-    const source = right.type === import_utils120.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils120.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils120.AST_NODE_TYPES.Identifier ? right.object.name : null;
+    const source = right.type === import_utils121.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils121.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils121.AST_NODE_TYPES.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   for (const statement of body2.body) {
@@ -22020,26 +22476,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === import_utils120.AST_NODE_TYPES.MemberExpression) {
-    const name = import_utils120.ASTUtils.getPropertyName(current);
+  while (current.type === import_utils121.AST_NODE_TYPES.MemberExpression) {
+    const name = import_utils121.ASTUtils.getPropertyName(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === import_utils120.AST_NODE_TYPES.ThisExpression ? root : null;
+  return current.type === import_utils121.AST_NODE_TYPES.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === import_utils120.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
-  if (value.type === import_utils120.AST_NODE_TYPES.AssignmentPattern) value = value.left;
-  if (value.type === import_utils120.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== import_utils120.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === import_utils121.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
+  if (value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern) value = value.left;
+  if (value.type === import_utils121.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== import_utils121.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === import_utils120.AST_NODE_TYPES.RestElement)
-        return property.argument.type === import_utils120.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === import_utils120.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-      return target.type === import_utils120.AST_NODE_TYPES.Identifier ? [target.name] : [];
+      if (property.type === import_utils121.AST_NODE_TYPES.RestElement)
+        return property.argument.type === import_utils121.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+      return target.type === import_utils121.AST_NODE_TYPES.Identifier ? [target.name] : [];
     })
   );
 }
@@ -22064,20 +22520,20 @@ var require_sql_access_class_default = createRule({
       const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === import_utils120.AST_NODE_TYPES.Identifier) {
-        const binding = import_utils120.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      if (node.type === import_utils121.AST_NODE_TYPES.Identifier) {
+        const binding = import_utils121.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
         if (binding?.defs.length !== 1 || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         const definition = binding.defs[0];
         return definition?.type === "Variable" && definition.node.init !== null && knownNonDatabase(definition.node.init, seen);
       }
-      return node.type === import_utils120.AST_NODE_TYPES.NewExpression && unwrappedNodeCallee?.type === import_utils120.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(unwrappedNodeCallee.name) && (import_utils120.ASTUtils.findVariable(context.sourceCode.getScope(unwrappedNodeCallee), unwrappedNodeCallee.name)?.defs.length ?? 0) === 0;
+      return node.type === import_utils121.AST_NODE_TYPES.NewExpression && unwrappedNodeCallee?.type === import_utils121.AST_NODE_TYPES.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(unwrappedNodeCallee.name) && (import_utils121.ASTUtils.findVariable(context.sourceCode.getScope(unwrappedNodeCallee), unwrappedNodeCallee.name)?.defs.length ?? 0) === 0;
     }
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils120.AST_NODE_TYPES.MemberExpression)
+        if (unwrappedNodeCallee.type !== import_utils121.AST_NODE_TYPES.MemberExpression)
           return;
-        const method = import_utils120.ASTUtils.getPropertyName(unwrappedNodeCallee);
+        const method = import_utils121.ASTUtils.getPropertyName(unwrappedNodeCallee);
         if (knownNonDatabase(unwrappedNodeCallee.object)) return;
         if (method === null || !isDatabaseOperation(method, unwrappedNodeCallee.object))
           return;
@@ -22093,7 +22549,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils121 = require("@typescript-eslint/utils");
+var import_utils122 = require("@typescript-eslint/utils");
 var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
   summary: "Require Next.js middleware and proxy matcher configuration to contain only build-time literals.",
   rationale: "Next.js must statically analyze matcher values at build time; computed values are ignored.",
@@ -22109,27 +22565,27 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function isStaticValue(node) {
   const value = unwrapExpression(node);
-  if (value.type === import_utils121.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils122.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils122.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils122.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils121.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils122.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils121.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils122.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils121.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils121.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils122.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils122.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName5(property) {
-  if (!property.computed && property.key.type === import_utils121.AST_NODE_TYPES.Identifier) return property.key.name;
-  return property.key.type === import_utils121.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
+  if (!property.computed && property.key.type === import_utils122.AST_NODE_TYPES.Identifier) return property.key.name;
+  return property.key.type === import_utils122.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
   name: "require-static-next-matcher",
@@ -22151,19 +22607,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils121.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils122.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils121.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils122.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression(declaration.init);
-          if (config.type !== import_utils121.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils121.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils121.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils122.AST_NODE_TYPES.Property || propertyName5(property) !== "matcher" || property.value.type === import_utils122.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -22177,7 +22633,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils122 = require("@typescript-eslint/utils");
+var import_utils123 = require("@typescript-eslint/utils");
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "Require explicit form-level initialization or a field default for directly bound Controller fields.",
   rationale: "React Hook Form exposes form-level defaultValues/values and field-level defaultValue as its explicit initialization mechanisms. A directly bound controlled field should not omit both mechanisms.",
@@ -22208,10 +22664,10 @@ var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
     }
   ]
 };
-function staticPropertyName(property) {
+function staticPropertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils122.AST_NODE_TYPES.Identifier) return property.key.name;
-  if (property.key.type === import_utils122.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
+  if (property.key.type === import_utils123.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils123.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
   return null;
 }
 var require_use_form_default_values_default = createRule({
@@ -22228,7 +22684,7 @@ var require_use_form_default_values_default = createRule({
     const imported = /* @__PURE__ */ new Map();
     const uninitializedForms = /* @__PURE__ */ new Set();
     const uninitializedControls = /* @__PURE__ */ new Set();
-    const bindingNamed = (node, name) => import_utils122.ASTUtils.findVariable(context.sourceCode.getScope(node), name);
+    const bindingNamed = (node, name) => import_utils123.ASTUtils.findVariable(context.sourceCode.getScope(node), name);
     const bindingOf = (node) => bindingNamed(node, node.name);
     const stable = (variable) => !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
     const importedKind = (node) => {
@@ -22241,49 +22697,49 @@ var require_use_form_default_values_default = createRule({
     };
     const isDefinitelyUndefined = (node) => {
       const value = unwrapExpression(node);
-      return value.type === import_utils122.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils122.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
+      return value.type === import_utils123.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils123.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
     };
     const uninitializedUseFormCall = (node) => {
       node = unwrapExpression(node);
       const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-      if (node.type !== import_utils122.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils122.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useForm") return false;
+      if (node.type !== import_utils123.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils123.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useForm") return false;
       const options = node.arguments[0];
-      return options?.type !== import_utils122.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
+      return options?.type !== import_utils123.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
     };
     const initializationState = (node) => {
       if (node === void 0) return "uninitialized";
-      if (node.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) return "unknown";
+      if (node.type !== import_utils123.AST_NODE_TYPES.ObjectExpression) return "unknown";
       const initialization = /* @__PURE__ */ new Map();
       for (const property of node.properties) {
-        if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
-        const name = staticPropertyName(property);
+        if (property.type === import_utils123.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property) continue;
+        const name = staticPropertyName2(property);
         if (name === "defaultValues" || name === "values") initialization.set(name, !isDefinitelyUndefined(property.value));
       }
       return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
     };
     const isUninitializedForm = (node) => {
       node = unwrapExpression(node);
-      if (node.type !== import_utils122.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils123.AST_NODE_TYPES.Identifier) return false;
       const variable = bindingOf(node);
       return variable !== null && stable(variable) && uninitializedForms.has(variable);
     };
     const isUninitializedControl = (node) => {
       node = unwrapExpression(node);
-      if (node.type === import_utils122.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils123.AST_NODE_TYPES.Identifier) {
         const variable = bindingOf(node);
         return variable !== null && stable(variable) && uninitializedControls.has(variable);
       }
-      return node.type === import_utils122.AST_NODE_TYPES.MemberExpression && import_utils122.ASTUtils.getPropertyName(node) !== null && (import_utils122.ASTUtils.getPropertyName(node) ?? "") === "control" && isUninitializedForm(node.object);
+      return node.type === import_utils123.AST_NODE_TYPES.MemberExpression && import_utils123.ASTUtils.getPropertyName(node) !== null && (import_utils123.ASTUtils.getPropertyName(node) ?? "") === "control" && isUninitializedForm(node.object);
     };
     const fieldOptionsNeedDefault = (node) => {
-      if (node?.type !== import_utils122.AST_NODE_TYPES.ObjectExpression) return false;
+      if (node?.type !== import_utils123.AST_NODE_TYPES.ObjectExpression) return false;
       let control = null;
       let hasDefault = false;
       for (const property of node.properties) {
-        if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return false;
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
-        const name = staticPropertyName(property);
+        if (property.type === import_utils123.AST_NODE_TYPES.SpreadElement || property.computed) return false;
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property) continue;
+        const name = staticPropertyName2(property);
         if (name === "control") control = property.value;
         if (name === "defaultValue") hasDefault = !isDefinitelyUndefined(property.value);
       }
@@ -22292,14 +22748,14 @@ var require_use_form_default_values_default = createRule({
     const jsxAttribute = (node, name) => {
       let result = null;
       for (const attribute of node.attributes) {
-        if (attribute.type === import_utils122.AST_NODE_TYPES.JSXSpreadAttribute) return null;
-        if (attribute.name.type === import_utils122.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === name) result = attribute;
+        if (attribute.type === import_utils123.AST_NODE_TYPES.JSXSpreadAttribute) return null;
+        if (attribute.name.type === import_utils123.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === name) result = attribute;
       }
       return result;
     };
     const trackDestructuredControl = (pattern) => {
       for (const property of pattern.properties) {
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property || staticPropertyName(property) !== "control" || property.value.type !== import_utils122.AST_NODE_TYPES.Identifier) continue;
+        if (property.type !== import_utils123.AST_NODE_TYPES.Property || staticPropertyName2(property) !== "control" || property.value.type !== import_utils123.AST_NODE_TYPES.Identifier) continue;
         const variable = bindingOf(property.value);
         if (variable !== null) uninitializedControls.add(variable);
       }
@@ -22308,8 +22764,8 @@ var require_use_form_default_values_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type !== import_utils122.AST_NODE_TYPES.ImportSpecifier) continue;
-          const name = specifier.imported.type === import_utils122.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+          if (specifier.type !== import_utils123.AST_NODE_TYPES.ImportSpecifier) continue;
+          const name = specifier.imported.type === import_utils123.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
           if (name !== "Controller" && name !== "useController" && name !== "useForm") continue;
           const variable = bindingOf(specifier.local);
           if (variable !== null) imported.set(variable, name);
@@ -22318,35 +22774,35 @@ var require_use_form_default_values_default = createRule({
       VariableDeclarator(node) {
         if (node.init === null) return;
         if (uninitializedUseFormCall(node.init)) {
-          if (node.id.type === import_utils122.AST_NODE_TYPES.Identifier) {
+          if (node.id.type === import_utils123.AST_NODE_TYPES.Identifier) {
             const variable = bindingOf(node.id);
             if (variable !== null) uninitializedForms.add(variable);
-          } else if (node.id.type === import_utils122.AST_NODE_TYPES.ObjectPattern) {
+          } else if (node.id.type === import_utils123.AST_NODE_TYPES.ObjectPattern) {
             trackDestructuredControl(node.id);
           }
           return;
         }
-        if (node.id.type === import_utils122.AST_NODE_TYPES.ObjectPattern && isUninitializedForm(node.init)) {
+        if (node.id.type === import_utils123.AST_NODE_TYPES.ObjectPattern && isUninitializedForm(node.init)) {
           trackDestructuredControl(node.id);
           return;
         }
-        if (node.id.type === import_utils122.AST_NODE_TYPES.Identifier && node.init.type === import_utils122.AST_NODE_TYPES.MemberExpression && import_utils122.ASTUtils.getPropertyName(node.init) !== null && (import_utils122.ASTUtils.getPropertyName(node.init) ?? "") === "control" && isUninitializedForm(node.init.object)) {
+        if (node.id.type === import_utils123.AST_NODE_TYPES.Identifier && node.init.type === import_utils123.AST_NODE_TYPES.MemberExpression && import_utils123.ASTUtils.getPropertyName(node.init) !== null && (import_utils123.ASTUtils.getPropertyName(node.init) ?? "") === "control" && isUninitializedForm(node.init.object)) {
           const variable = bindingOf(node.id);
           if (variable !== null) uninitializedControls.add(variable);
         }
       },
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils122.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === import_utils122.AST_NODE_TYPES.SpreadElement ? void 0 : node.arguments[0])) return;
+        if (unwrappedNodeCallee.type !== import_utils123.AST_NODE_TYPES.Identifier || importedKind(unwrappedNodeCallee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === import_utils123.AST_NODE_TYPES.SpreadElement ? void 0 : node.arguments[0])) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       },
       JSXOpeningElement(node) {
-        if (node.name.type !== import_utils122.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
-        if (node.attributes.some((attribute) => attribute.type === import_utils122.AST_NODE_TYPES.JSXSpreadAttribute)) return;
+        if (node.name.type !== import_utils123.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.attributes.some((attribute) => attribute.type === import_utils123.AST_NODE_TYPES.JSXSpreadAttribute)) return;
         const control = jsxAttribute(node, "control");
-        if (control?.value?.type !== import_utils122.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils122.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
+        if (control?.value?.type !== import_utils123.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils123.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
         const defaultValue = jsxAttribute(node, "defaultValue");
-        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== import_utils122.AST_NODE_TYPES.JSXExpressionContainer || defaultValue.value.expression.type !== import_utils122.AST_NODE_TYPES.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
+        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== import_utils123.AST_NODE_TYPES.JSXExpressionContainer || defaultValue.value.expression.type !== import_utils123.AST_NODE_TYPES.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       }
     };
@@ -22354,7 +22810,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils123 = require("@typescript-eslint/utils");
+var import_utils124 = require("@typescript-eslint/utils");
 var ACTION_MODULE_RE = /(?:^|\/)app\/.*\/(?:actions|[^/]+-actions)\.[cm]?[jt]s$/u;
 var REQUIRE_USE_SERVER_IN_ACTIONS_FILE_DOCUMENTATION = {
   summary: "route action module missing the use server directive",
@@ -22421,7 +22877,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils124 = require("@typescript-eslint/utils");
+var import_utils125 = require("@typescript-eslint/utils");
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
   rationale: "FormData values are untrusted strings or files and need runtime validation before use.",
@@ -22447,14 +22903,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils124.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils125.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils124.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils125.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils124.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils125.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -22463,12 +22919,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils124.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils125.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils124.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils125.AST_NODE_TYPES.CallExpression) return false;
   const callee = unwrapExpression(current.callee);
-  return callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && import_utils124.ASTUtils.getPropertyName(callee) === "formData";
+  return callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && import_utils125.ASTUtils.getPropertyName(callee) === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -22489,29 +22945,29 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils124.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils125.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
     const isFormDataGetCall = (node) => {
       const callee = unwrapExpression(node.callee);
-      const calleeReceiver = callee.type === import_utils124.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-      if (callee.type !== import_utils124.AST_NODE_TYPES.MemberExpression) return false;
-      if (import_utils124.ASTUtils.getPropertyName(callee) === null || !FORM_VALUE_METHODS.has(import_utils124.ASTUtils.getPropertyName(callee) ?? "")) {
+      const calleeReceiver = callee.type === import_utils125.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+      if (callee.type !== import_utils125.AST_NODE_TYPES.MemberExpression) return false;
+      if (import_utils125.ASTUtils.getPropertyName(callee) === null || !FORM_VALUE_METHODS.has(import_utils125.ASTUtils.getPropertyName(callee) ?? "")) {
         return false;
       }
       return isFormSourceIdentifier(calleeReceiver);
     };
     const isFormSourceIdentifier = (node) => {
       node = unwrapExpression(node);
-      if (node.type !== import_utils124.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.Identifier) return false;
       const conventionalName = /formdata/i.test(node.name);
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils124.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils125.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -22524,24 +22980,24 @@ var require_zod_form_validation_default = createRule({
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
         if (isZodParseCall(parent)) return parent;
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils124.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils125.AST_NODE_TYPES.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && parent.callee.object.type === import_utils124.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && import_utils124.ASTUtils.getPropertyName(parent.callee) === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && parent.callee.object.type === import_utils125.AST_NODE_TYPES.Identifier && parent.callee.object.name === "Object" && import_utils125.ASTUtils.getPropertyName(parent.callee) === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === import_utils124.AST_NODE_TYPES.CallExpression || parent.type === import_utils124.AST_NODE_TYPES.NewExpression || parent.type === import_utils124.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils124.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils124.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils124.AST_NODE_TYPES.FunctionDeclaration) return null;
+        if (parent.type === import_utils125.AST_NODE_TYPES.CallExpression || parent.type === import_utils125.AST_NODE_TYPES.NewExpression || parent.type === import_utils125.AST_NODE_TYPES.TaggedTemplateExpression || parent.type === import_utils125.AST_NODE_TYPES.ArrowFunctionExpression || parent.type === import_utils125.AST_NODE_TYPES.FunctionExpression || parent.type === import_utils125.AST_NODE_TYPES.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils124.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.CallExpression) return false;
       const callee = unwrapExpression(node.callee);
-      const calleeReceiver = callee.type === import_utils124.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-      if (callee.type !== import_utils124.AST_NODE_TYPES.MemberExpression || import_utils124.ASTUtils.getPropertyName(callee) === null || !ZOD_PARSE_METHODS.has(import_utils124.ASTUtils.getPropertyName(callee) ?? "")) {
+      const calleeReceiver = callee.type === import_utils125.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+      if (callee.type !== import_utils125.AST_NODE_TYPES.MemberExpression || import_utils125.ASTUtils.getPropertyName(callee) === null || !ZOD_PARSE_METHODS.has(import_utils125.ASTUtils.getPropertyName(callee) ?? "")) {
         return false;
       }
       const root = zodReceiverRoot(calleeReceiver);
@@ -22555,25 +23011,25 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils124.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils125.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils124.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils124.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils124.AST_NODE_TYPES.Literal || init?.type === import_utils124.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils124.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils125.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils125.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils125.AST_NODE_TYPES.Literal || init?.type === import_utils125.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils125.AST_NODE_TYPES.FunctionExpression;
     };
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils124.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils125.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === import_utils124.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils124.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils124.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils124.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils125.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils125.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils125.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils125.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils124.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils124.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils125.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils125.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -22582,7 +23038,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils124.AST_NODE_TYPES.BlockStatement || parent.type === import_utils124.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils125.AST_NODE_TYPES.BlockStatement || parent.type === import_utils125.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -22597,7 +23053,7 @@ var require_zod_form_validation_default = createRule({
       if (declarationStatement === null || validationStatement === null || declarationStatement.parent !== validationStatement.parent || validationStatement.range[0] <= declarationStatement.range[1] || hasConditionalAncestorBeforeStatement(parse2, validationStatement)) {
         return null;
       }
-      if (validationStatement.type !== import_utils124.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils124.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils125.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils125.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -22610,7 +23066,7 @@ var require_zod_form_validation_default = createRule({
     const isAwaitedBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils124.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils125.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -22618,7 +23074,7 @@ var require_zod_form_validation_default = createRule({
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils124.AST_NODE_TYPES.LogicalExpression || current.type === import_utils124.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils125.AST_NODE_TYPES.LogicalExpression || current.type === import_utils125.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -22627,20 +23083,20 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = unwrapExpression(call.callee);
-      return callee.type === import_utils124.AST_NODE_TYPES.MemberExpression && import_utils124.ASTUtils.getPropertyName(callee) !== null ? import_utils124.ASTUtils.getPropertyName(callee) ?? "" : null;
+      return callee.type === import_utils125.AST_NODE_TYPES.MemberExpression && import_utils125.ASTUtils.getPropertyName(callee) !== null ? import_utils125.ASTUtils.getPropertyName(callee) ?? "" : null;
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils124.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils125.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils124.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils125.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils124.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils124.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils125.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils125.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -22651,23 +23107,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils124.AST_NODE_TYPES.ReturnStatement || node.type === import_utils124.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils125.AST_NODE_TYPES.ReturnStatement || node.type === import_utils125.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils124.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils125.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
       const last = node.body.at(-1);
       return last !== void 0 && blockTerminates(last);
     };
     const narrowingIf = (identifier) => {
       const comparison = identifier.parent;
-      if (comparison?.type !== import_utils124.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils124.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils125.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils125.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils124.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils125.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils124.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils125.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -22687,7 +23143,7 @@ var require_zod_form_validation_default = createRule({
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
       const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
-        (identifier) => identifier.type === import_utils124.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils125.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -22713,7 +23169,7 @@ var require_zod_form_validation_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils124.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils124.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils124.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils124.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils125.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils125.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils125.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils125.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -22734,7 +23190,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils125 = require("@typescript-eslint/utils");
+var import_utils126 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Review conflict handling for embedded inserts in replay-named callables.",
   rationale: "Names such as seed, enqueue, or upsert suggest that repeated execution deserves a conflict-policy review, but do not prove a replay contract.",
@@ -22803,7 +23259,7 @@ function expressionCallableName(current) {
 }
 
 // src/rules/stepdown.ts
-var import_utils126 = require("@typescript-eslint/utils");
+var import_utils127 = require("@typescript-eslint/utils");
 var STEPDOWN_DOCUMENTATION = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -22821,7 +23277,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils126.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils126.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils127.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils127.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.key, definition]));
@@ -22917,7 +23373,7 @@ function cycleComponents(graph) {
   return components;
 }
 function isErasedExpression2(node) {
-  return node.type === import_utils126.AST_NODE_TYPES.TSAsExpression || node.type === import_utils126.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils126.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils126.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils126.AST_NODE_TYPES.TSInstantiationExpression;
+  return node.type === import_utils127.AST_NODE_TYPES.TSAsExpression || node.type === import_utils127.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils127.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils127.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils127.AST_NODE_TYPES.TSInstantiationExpression;
 }
 function unwrapExpression4(node) {
   let current = node;
@@ -22941,11 +23397,11 @@ function localCallCount(context, node, owner) {
     if (current === void 0 || enclosingFunction5(context, current) !== owner) return null;
     const expression = wrappedExpression(current);
     const parent = expression.parent;
-    if (parent?.type === import_utils126.AST_NODE_TYPES.CallExpression && parent.callee === expression) {
+    if (parent?.type === import_utils127.AST_NODE_TYPES.CallExpression && parent.callee === expression) {
       count += 1;
       continue;
     }
-    if (parent?.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || parent.init !== expression || parent.id.type !== import_utils126.AST_NODE_TYPES.Identifier || parent.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || parent.parent.kind !== "const") return null;
+    if (parent?.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || parent.init !== expression || parent.id.type !== import_utils127.AST_NODE_TYPES.Identifier || parent.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || parent.parent.kind !== "const") return null;
     const variable = context.sourceCode.getDeclaredVariables(parent)[0];
     if (variable === void 0 || seen.has(variable) || !stableVariable(variable)) return null;
     seen.add(variable);
@@ -22960,11 +23416,11 @@ function declarationScope(context, program) {
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
     program.body.flatMap((statement) => {
-      const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils126.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils127.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
-  const exported = program.type === import_utils126.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
+  const exported = program.type === import_utils127.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
   const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1);
   const definitions = scopeDefinitions.filter(
     (definition) => !exported.has(definition.name) && !overloadNames.has(definition.name)
@@ -22976,7 +23432,7 @@ function declarationScope(context, program) {
     runtimeBarrierPrefix.push((runtimeBarrierPrefix.at(-1) ?? 0) + (isDeferredModuleStatement(statement) ? 0 : 1));
   }
   const canMove = (helper, caller) => {
-    if (helper.node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration) return true;
+    if (helper.node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration) return true;
     const helperIndex = statementIndex(helper);
     const callerIndex = statementIndex(caller);
     return helperIndex !== void 0 && callerIndex !== void 0 && runtimeBarrierPrefix[callerIndex + 1] === runtimeBarrierPrefix[helperIndex + 1];
@@ -23018,26 +23474,26 @@ function moduleCallGraph(context, scopeDefinitions) {
   return { calls, pinned };
 }
 function isDeferredModuleStatement(statement) {
-  const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-  if (node === null || node.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils126.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils126.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils126.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils126.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils126.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils126.AST_NODE_TYPES.EmptyStatement) return true;
-  return node.type === import_utils126.AST_NODE_TYPES.VariableDeclaration && node.declarations.every(
-    (declaration) => declaration.id.type === import_utils126.AST_NODE_TYPES.Identifier && declaration.init !== null && isFunction(unwrapExpression4(declaration.init))
+  const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+  if (node === null || node.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils127.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils127.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils127.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils127.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils127.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils127.AST_NODE_TYPES.EmptyStatement) return true;
+  return node.type === import_utils127.AST_NODE_TYPES.VariableDeclaration && node.declarations.every(
+    (declaration) => declaration.id.type === import_utils127.AST_NODE_TYPES.Identifier && declaration.init !== null && isFunction(unwrapExpression4(declaration.init))
   );
 }
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   function collectNamedExports(statement) {
-    if (statement.type !== import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
-    if (statement.declaration?.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
+    if (statement.declaration?.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils126.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils127.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils126.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils127.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils126.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils127.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
@@ -23046,23 +23502,23 @@ function exportedNames(program) {
     collectNamedExports(statement);
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils126.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils127.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === import_utils126.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils126.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils126.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils127.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils127.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils127.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ key: node.id.name, name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const" || node.declarations.length !== 1) continue;
+    if (node?.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const" || node.declarations.length !== 1) continue;
     for (const declarator of node.declarations) {
       const initializer = declarator.init === null ? null : unwrapExpression4(declarator.init);
-      if (declarator.id.type === import_utils126.AST_NODE_TYPES.Identifier && initializer !== null && isFunction(initializer)) {
+      if (declarator.id.type === import_utils127.AST_NODE_TYPES.Identifier && initializer !== null && isFunction(initializer)) {
         definitions.push({
           key: declarator.id.name,
           name: declarator.id.name,
@@ -23076,25 +23532,25 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  if (!node.computed && node.key.type === import_utils126.AST_NODE_TYPES.Identifier) return node.key.name;
-  return node.key.type === import_utils126.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
+  if (node.key.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  if (!node.computed && node.key.type === import_utils127.AST_NODE_TYPES.Identifier) return node.key.name;
+  return node.key.type === import_utils127.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
 }
 function methodKey(name, isStatic2) {
   return `${isStatic2 ? "static" : "instance"}:${name}`;
 }
 function receiverDomain(context, object, receivers, thisIsStatic) {
   const unwrapped = unwrapExpression4(object);
-  if (unwrapped.type === import_utils126.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
+  if (unwrapped.type === import_utils127.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
   return externalReceiverDomain(context, unwrapped, receivers);
 }
 function externalReceiverDomain(context, object, receivers) {
   const origin = receiverOrigin(context, object, receivers);
   if (origin === null || typeof origin === "boolean") return origin;
-  if (origin.type === import_utils126.AST_NODE_TYPES.NewExpression) {
+  if (origin.type === import_utils127.AST_NODE_TYPES.NewExpression) {
     return receiverOrigin(context, origin.callee, receivers) === true ? false : null;
   }
-  if (origin.type === import_utils126.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils126.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils126.AST_NODE_TYPES.Literal || origin.type === import_utils126.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils126.AST_NODE_TYPES.FunctionExpression) return "unrelated";
+  if (origin.type === import_utils127.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils127.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils127.AST_NODE_TYPES.Literal || origin.type === import_utils127.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils127.AST_NODE_TYPES.FunctionExpression) return "unrelated";
   return null;
 }
 function receiverOrigin(context, object, receivers) {
@@ -23102,8 +23558,8 @@ function receiverOrigin(context, object, receivers) {
   const seen = /* @__PURE__ */ new Set();
   while (true) {
     const unwrapped = unwrapExpression4(current);
-    if (unwrapped.type !== import_utils126.AST_NODE_TYPES.Identifier) return unwrapped;
-    const variable = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
+    if (unwrapped.type !== import_utils127.AST_NODE_TYPES.Identifier) return unwrapped;
+    const variable = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
     if (variable === null) return null;
     const known = receivers.get(variable);
     if (known !== void 0) return known;
@@ -23116,25 +23572,25 @@ function immutableInitializer(variable, seen) {
   if (seen.has(variable) || !stableVariable(variable) || variable.defs.length !== 1) return null;
   seen.add(variable);
   const definition = variable.defs[0];
-  if (definition?.node.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
+  if (definition?.node.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
   return definition.node.init;
 }
 function stableVariable(variable) {
   return !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils126.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils126.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils127.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils127.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
-  const nested = nestedFunction || isFunction(node) || node.type === import_utils126.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils126.AST_NODE_TYPES.ClassExpression;
+  const nested = nestedFunction || isFunction(node) || node.type === import_utils127.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils127.AST_NODE_TYPES.ClassExpression;
   forEachAstChild(node, visitorKeys, (child) => walk(child, visitorKeys, visit, nested));
 }
 function classScope(context, node, computedReferences) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils126.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils127.AST_NODE_TYPES.MethodDefinition
   );
   const counts = classMethodCounts(node.body, methods);
   const implementations = methods.filter((method) => isFunction(method.value));
@@ -23145,7 +23601,7 @@ function classScope(context, node, computedReferences) {
     return name !== null && key !== null && implementationCounts.get(key) === 1 ? [{ key, name, node: method }] : [];
   });
   const definitions = scopeDefinitions.filter(
-    ({ key, node: method }) => (method.accessibility === "private" || method.key.type === import_utils126.AST_NODE_TYPES.PrivateIdentifier) && counts.get(key) === 1 && method.decorators.length === 0 && !method.computed && method.kind === "method"
+    ({ key, node: method }) => (method.accessibility === "private" || method.key.type === import_utils127.AST_NODE_TYPES.PrivateIdentifier) && counts.get(key) === 1 && method.decorators.length === 0 && !method.computed && method.kind === "method"
   );
   if (definitions.length === 0) return;
   const methodKeys = new Set(scopeDefinitions.map((definition) => definition.key));
@@ -23161,11 +23617,11 @@ function classScope(context, node, computedReferences) {
   };
   function pinDestructuredMembers(binding, domain) {
     for (const property of binding.properties) {
-      if (property.type === import_utils126.AST_NODE_TYPES.RestElement || property.computed) {
+      if (property.type === import_utils127.AST_NODE_TYPES.RestElement || property.computed) {
         pinNames(null, domain);
-      } else if (property.key.type === import_utils126.AST_NODE_TYPES.Identifier) {
+      } else if (property.key.type === import_utils127.AST_NODE_TYPES.Identifier) {
         pinNames(property.key.name, domain);
-      } else if (property.key.type === import_utils126.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
+      } else if (property.key.type === import_utils127.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
         pinNames(property.key.value, domain);
       }
     }
@@ -23187,15 +23643,15 @@ function classScope(context, node, computedReferences) {
       }
     }
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils126.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
+      if (nestedFunction || current.type !== import_utils127.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
       const domain = receiverDomain(context, current.init, receivers, method.static);
       if (domain === null || domain === "unrelated") return;
-      if (current.id.type === import_utils126.AST_NODE_TYPES.ObjectPattern) {
+      if (current.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern) {
         pinDestructuredMembers(current.id, domain);
         return;
       }
-      if (current.id.type !== import_utils126.AST_NODE_TYPES.Identifier) return;
-      if (current.parent.type !== import_utils126.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const") {
+      if (current.id.type !== import_utils127.AST_NODE_TYPES.Identifier) return;
+      if (current.parent.type !== import_utils127.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const") {
         pinNames(null, domain);
         return;
       }
@@ -23204,7 +23660,7 @@ function classScope(context, node, computedReferences) {
       const local = variable.references.every((reference) => {
         if (!reference.isRead()) return true;
         const expression = wrappedExpression(reference.identifier);
-        return enclosingFunction5(context, reference.identifier) === methodFunction && expression.parent?.type === import_utils126.AST_NODE_TYPES.MemberExpression && expression.parent.object === expression;
+        return enclosingFunction5(context, reference.identifier) === methodFunction && expression.parent?.type === import_utils127.AST_NODE_TYPES.MemberExpression && expression.parent.object === expression;
       });
       if (local) receivers.set(variable, domain);
       else pinNames(null, domain);
@@ -23216,7 +23672,7 @@ function classScope(context, node, computedReferences) {
         const domain2 = receiverDomain(context, destructuring.value, receivers, method.static);
         if (domain2 !== "unrelated") pinDestructuredMembers(destructuring.binding, domain2);
       }
-      if (current.type !== import_utils126.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return;
       const domain = receiverDomain(context, current.object, receivers, method.static);
       const targetName = referencedPropertyName(current);
       if (domain === "unrelated") return;
@@ -23250,9 +23706,9 @@ function classScope(context, node, computedReferences) {
   }
   for (const method of methods) collectMethodCalls(method);
   for (const member of node.body.body) {
-    if (member.type === import_utils126.AST_NODE_TYPES.MethodDefinition || member.type === import_utils126.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils127.AST_NODE_TYPES.MethodDefinition || member.type === import_utils127.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils126.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return;
       if (externalReceiverDomain(context, current.object, classReceivers) === "unrelated") return;
       pinNames(referencedPropertyName(current));
     });
@@ -23284,32 +23740,32 @@ function classScope(context, node, computedReferences) {
 function classReceiverBindings(context, node) {
   const classReceivers = /* @__PURE__ */ new Map();
   if (node.id !== null) {
-    const internal = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null && stableVariable(internal)) classReceivers.set(internal, true);
   }
-  if (node.type === import_utils126.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils126.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils126.AST_NODE_TYPES.Identifier && node.parent.parent.type === import_utils126.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.kind === "const") {
-    const outer = import_utils126.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils127.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils127.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils127.AST_NODE_TYPES.Identifier && node.parent.parent.type === import_utils127.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.kind === "const") {
+    const outer = import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null && stableVariable(outer)) classReceivers.set(outer, true);
   }
   return classReceivers;
 }
 function receiverDestructuring(node) {
-  if (node.type === import_utils126.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils126.AST_NODE_TYPES.ObjectPattern && node.init !== null) {
+  if (node.type === import_utils127.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern && node.init !== null) {
     return { binding: node.id, value: node.init };
   }
-  if ((node.type === import_utils126.AST_NODE_TYPES.AssignmentPattern || node.type === import_utils126.AST_NODE_TYPES.AssignmentExpression) && node.left.type === import_utils126.AST_NODE_TYPES.ObjectPattern) {
+  if ((node.type === import_utils127.AST_NODE_TYPES.AssignmentPattern || node.type === import_utils127.AST_NODE_TYPES.AssignmentExpression) && node.left.type === import_utils127.AST_NODE_TYPES.ObjectPattern) {
     return { binding: node.left, value: node.right };
   }
   return null;
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils126.AST_NODE_TYPES.StaticBlock:
+    case import_utils127.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils126.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils126.AST_NODE_TYPES.AccessorProperty:
+    case import_utils127.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils127.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils126.AST_NODE_TYPES.MethodDefinition:
+    case import_utils127.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -23339,14 +23795,14 @@ var stepdown_default = createRule({
         classes.push(node);
       },
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression": (node) => {
-        if (isFunction(node) && node.body?.type === import_utils126.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
+        if (isFunction(node) && node.body?.type === import_utils127.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
       },
       "Program:exit": (program) => {
         declarationScope(context, program);
         for (const body2 of functionBodies) declarationScope(context, body2);
         const computedReferences = [];
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils126.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
+          if (node.type === import_utils127.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
         });
         for (const node of classes) classScope(context, node, computedReferences);
       }
@@ -23363,8 +23819,8 @@ function classMethodCounts(body2, methods) {
     }
   }
   for (const member of body2.body) {
-    if (member.type !== import_utils126.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils126.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils127.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils127.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) {
       const key = methodKey(name, member.static);
       counts.set(key, (counts.get(key) ?? 0) + 1);
@@ -23374,7 +23830,7 @@ function classMethodCounts(body2, methods) {
 }
 
 // src/rules/source-coupled-test.ts
-var import_utils127 = require("@typescript-eslint/utils");
+var import_utils128 = require("@typescript-eslint/utils");
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
@@ -23448,16 +23904,16 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
 function unwrap6(node) {
   for (; ; ) {
     node = unwrapExpression(node);
-    if (node.type === import_utils127.AST_NODE_TYPES.AwaitExpression) node = node.argument;
-    else if (node.type === import_utils127.AST_NODE_TYPES.ChainExpression) node = node.expression;
+    if (node.type === import_utils128.AST_NODE_TYPES.AwaitExpression) node = node.argument;
+    else if (node.type === import_utils128.AST_NODE_TYPES.ChainExpression) node = node.expression;
     else return node;
   }
 }
 function stringValue(node) {
   const current = unwrap6(node);
-  if (current.type === import_utils127.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils127.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+  if (current.type === import_utils128.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils128.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -23469,7 +23925,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap6(node);
-  if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils127.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils127.AST_NODE_TYPES.SpreadElement) return null;
+  if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils128.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils128.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -23491,7 +23947,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const scopes = [newScope()];
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
-      const bindingOf = (node) => import_utils127.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+      const bindingOf = (node) => import_utils128.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
       const assertionKind = (node) => {
         const binding = bindingOf(node);
         if (binding === null || binding.defs.length === 0) {
@@ -23525,75 +23981,75 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils127.AST_NODE_TYPES.Identifier) return visible("paths", current);
-        if (current.type === import_utils127.AST_NODE_TYPES.CallExpression || current.type === import_utils127.AST_NODE_TYPES.NewExpression) {
+        if (current.type === import_utils128.AST_NODE_TYPES.Identifier) return visible("paths", current);
+        if (current.type === import_utils128.AST_NODE_TYPES.CallExpression || current.type === import_utils128.AST_NODE_TYPES.NewExpression) {
           const callee = unwrapExpression(current.callee);
           const first = current.arguments[0];
-          if (first === void 0 || first.type === import_utils127.AST_NODE_TYPES.SpreadElement) return false;
-          if (current.type === import_utils127.AST_NODE_TYPES.NewExpression && callee.type === import_utils127.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === import_utils127.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils127.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils127.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils127.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === import_utils128.AST_NODE_TYPES.SpreadElement) return false;
+          if (current.type === import_utils128.AST_NODE_TYPES.NewExpression && callee.type === import_utils128.AST_NODE_TYPES.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === import_utils128.AST_NODE_TYPES.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === import_utils128.AST_NODE_TYPES.ImportSpecifier && definition.node.imported.type === import_utils128.AST_NODE_TYPES.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === import_utils128.AST_NODE_TYPES.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
         }
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap6(node);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type === import_utils127.AST_NODE_TYPES.Identifier) {
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type === import_utils128.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return false;
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return false;
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         const object = unwrap6(calleeReceiver);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils127.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils128.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap6(node);
-        if (current.type === import_utils127.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
+        if (current.type === import_utils128.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils127.AST_NODE_TYPES.MemberExpression && import_utils127.ASTUtils.getPropertyName(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils128.AST_NODE_TYPES.MemberExpression && import_utils128.ASTUtils.getPropertyName(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(calleeReceiver) : /* @__PURE__ */ new Set();
       };
       const evidenceOrigins = (node) => {
         const current = unwrap6(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils127.AST_NODE_TYPES.BinaryExpression || current.type === import_utils127.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils127.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils127.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils128.AST_NODE_TYPES.BinaryExpression || current.type === import_utils128.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils128.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils128.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = import_utils127.ASTUtils.getPropertyName(callee);
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = import_utils128.ASTUtils.getPropertyName(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(calleeReceiver);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap6(node.callee);
-        const calleeReceiver = callee.type === import_utils127.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
-        if (callee.type === import_utils127.AST_NODE_TYPES.Identifier && assertionKind(callee) === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        const calleeReceiver = callee.type === import_utils128.AST_NODE_TYPES.MemberExpression ? unwrapExpression(callee.object) : callee;
+        if (callee.type === import_utils128.AST_NODE_TYPES.Identifier && assertionKind(callee) === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils127.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const matcher = import_utils127.ASTUtils.getPropertyName(callee);
+        if (callee.type !== import_utils128.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        const matcher = import_utils128.ASTUtils.getPropertyName(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap6(calleeReceiver);
-        while (receiver.type === import_utils127.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(import_utils127.ASTUtils.getPropertyName(receiver) ?? "")) receiver = unwrap6(receiver.object);
-        const expectCallee = receiver.type === import_utils127.AST_NODE_TYPES.CallExpression ? unwrapExpression(receiver.callee) : null;
-        if (receiver.type === import_utils127.AST_NODE_TYPES.CallExpression && expectCallee?.type === import_utils127.AST_NODE_TYPES.Identifier && assertionKind(expectCallee) === "expect") {
+        while (receiver.type === import_utils128.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(import_utils128.ASTUtils.getPropertyName(receiver) ?? "")) receiver = unwrap6(receiver.object);
+        const expectCallee = receiver.type === import_utils128.AST_NODE_TYPES.CallExpression ? unwrapExpression(receiver.callee) : null;
+        if (receiver.type === import_utils128.AST_NODE_TYPES.CallExpression && expectCallee?.type === import_utils128.AST_NODE_TYPES.Identifier && assertionKind(expectCallee) === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils127.AST_NODE_TYPES.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils127.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils128.AST_NODE_TYPES.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils128.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -23615,7 +24071,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap6(node);
-        return current.type === import_utils127.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils127.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        return current.type === import_utils128.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils128.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -23625,8 +24081,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       function declareFsReaders(pattern) {
         for (const property of pattern.properties) {
-          if (property.type !== import_utils127.AST_NODE_TYPES.Property || property.value.type !== import_utils127.AST_NODE_TYPES.Identifier) continue;
-          const key = property.key.type === import_utils127.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils127.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+          if (property.type !== import_utils128.AST_NODE_TYPES.Property || property.value.type !== import_utils128.AST_NODE_TYPES.Identifier) continue;
+          const key = property.key.type === import_utils128.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils128.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
           if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
         }
       }
@@ -23635,8 +24091,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           const source = importSource(node);
           if (source === null || !FS_MODULES.has(source)) return;
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils127.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils128.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -23649,26 +24105,26 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (node.init === null) return;
           const required = requireSource(node.init);
           const initializer = unwrap6(node.init);
-          if (required !== null && initializer.type === import_utils127.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils127.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils127.AST_NODE_TYPES.Identifier) {
+          if (required !== null && initializer.type === import_utils128.AST_NODE_TYPES.CallExpression && initializer.callee.type === import_utils128.AST_NODE_TYPES.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils128.AST_NODE_TYPES.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils127.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils128.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             declareFsReaders(node.id);
             return;
           }
-          if (node.id.type !== import_utils127.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils128.AST_NODE_TYPES.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils127.AST_NODE_TYPES.Identifier) declare(node.left, {});
+          if (node.left.type === import_utils128.AST_NODE_TYPES.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap6(node.right);
-          const collection = right.type === import_utils127.AST_NODE_TYPES.Identifier && visible("collections", right);
-          const left = node.left.type === import_utils127.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils127.AST_NODE_TYPES.Identifier) declare(left, { path: true });
+          const collection = right.type === import_utils128.AST_NODE_TYPES.Identifier && visible("collections", right);
+          const left = node.left.type === import_utils128.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils128.AST_NODE_TYPES.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -23686,22 +24142,22 @@ var source_coupled_test_default = createSourceCoupledRule(
   GENERAL_SOURCE_SUFFIX_RE
 );
 function importedAssertionKind(specifier) {
-  if (specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils127.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils127.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.parent.type !== import_utils127.AST_NODE_TYPES.ImportDeclaration) return null;
+  if (specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils128.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils128.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.parent.type !== import_utils128.AST_NODE_TYPES.ImportDeclaration) return null;
   const source = importSource(specifier.parent);
   if (source !== null && ASSERT_MODULES.has(source)) {
-    if (specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier) return "assert";
-    const imported2 = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+    if (specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier) return "assert";
+    const imported2 = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
     if (imported2 === "strict" || ASSERT_MATCHERS.has(imported2)) return "assert";
     return null;
   }
-  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== import_utils127.AST_NODE_TYPES.ImportSpecifier) return null;
-  const imported = specifier.imported.type === import_utils127.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== import_utils128.AST_NODE_TYPES.ImportSpecifier) return null;
+  const imported = specifier.imported.type === import_utils128.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
   if (imported === "assert" || imported === "expect") return imported;
   return null;
 }
 
 // src/rules/sole-export-matches-filename.ts
-var import_utils128 = require("@typescript-eslint/utils");
+var import_utils129 = require("@typescript-eslint/utils");
 
 // src/rules/_is-framework-entrypoint.ts
 var import_node_fs2 = require("fs");
@@ -23817,7 +24273,7 @@ var sole_export_matches_filename_default = createRule({
         if (only === void 0) return;
         if (isFrameworkEntrypoint(normalizedFilename, only.key)) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
-        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils128.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
+        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils129.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
@@ -23867,7 +24323,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils129 = require("@typescript-eslint/utils");
+var import_utils130 = require("@typescript-eslint/utils");
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
   rationale: "A reusable Zod schema is a runtime type contract. PascalCase mirrors that role; SCREAMING_SNAKE_CASE should remain reserved for scalar values and lookup tables.",
@@ -23999,19 +24455,19 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => import_utils129.ASTUtils.getPropertyName(callee) !== null ? import_utils129.ASTUtils.getPropertyName(callee) ?? "" : null;
+var terminalMethodName = (callee) => import_utils130.ASTUtils.getPropertyName(callee) !== null ? import_utils130.ASTUtils.getPropertyName(callee) ?? "" : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils129.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils130.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.CallExpression) {
       current = unwrapExpression(current.callee);
       continue;
     }
@@ -24023,13 +24479,13 @@ var chainMemberNames2 = (node) => {
   let current = node;
   for (; ; ) {
     current = unwrapExpression(current);
-    if (current.type === import_utils129.AST_NODE_TYPES.MemberExpression) {
-      if (import_utils129.ASTUtils.getPropertyName(current) === null) return [];
-      names.push(import_utils129.ASTUtils.getPropertyName(current) ?? "");
+    if (current.type === import_utils130.AST_NODE_TYPES.MemberExpression) {
+      if (import_utils130.ASTUtils.getPropertyName(current) === null) return [];
+      names.push(import_utils130.ASTUtils.getPropertyName(current) ?? "");
       current = current.object;
       continue;
     }
-    if (current.type === import_utils129.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils130.AST_NODE_TYPES.CallExpression) {
       current = unwrapExpression(current.callee);
       continue;
     }
@@ -24040,9 +24496,9 @@ var chainMemberNames2 = (node) => {
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils129.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils130.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils129.AST_NODE_TYPES.Program || owner.type === import_utils129.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils129.AST_NODE_TYPES.Program;
+  return owner.type === import_utils130.AST_NODE_TYPES.Program || owner.type === import_utils130.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils130.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -24062,7 +24518,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return import_utils129.ASTUtils.findVariable(
+      return import_utils130.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -24073,10 +24529,10 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression(expression);
-      if (init.type === import_utils129.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils129.AST_NODE_TYPES.CallExpression) return false;
+      if (init.type === import_utils130.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils130.AST_NODE_TYPES.CallExpression) return false;
       const callee = unwrapExpression(init.callee);
-      if (callee.type !== import_utils129.AST_NODE_TYPES.MemberExpression) {
+      if (callee.type !== import_utils130.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(callee);
@@ -24106,7 +24562,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils129.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils129.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils129.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils129.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils130.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils130.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils130.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils130.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -24115,7 +24571,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
         if (!isModuleDeclarator(node)) return;
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (node.id.type !== import_utils129.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils130.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -24317,6 +24773,7 @@ var RULES = {
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
   "repeated-static-call-cases": repeated_static_call_cases_default,
   "prefer-zod-infer": prefer_zod_infer_default,
+  "named-child-schema-type": named_child_schema_type_default,
   "prefer-zod-parse-output-type": prefer_zod_parse_output_type_default,
   "require-assert-never": require_assert_never_default,
   "require-fetch-timeout": require_fetch_timeout_default,
@@ -24333,7 +24790,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "16.4.7"
+  version: package_default.version
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {
@@ -24342,6 +24799,7 @@ var LIBRARY_IMPORT_POLICY = ["error", {
 }];
 var ADVISORY_RULES = [
   "@sarj/excessive-commentary",
+  "@sarj/named-child-schema-type",
   "@sarj/no-bespoke-api-case-conversion",
   "@sarj/no-duplicate-test-case",
   "@sarj/no-json-stringify-object-equality",
@@ -24364,6 +24822,7 @@ var ADVISORY_RULES = [
   "@sarj/require-sql-access-class"
 ];
 var RECOMMENDED_RULES = {
+  "@sarj/named-child-schema-type": "warn",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",
@@ -24481,6 +24940,7 @@ var RECOMMENDED_RULES = {
   "@sarj/require-pascal-case-zod-schema-name": "error"
 };
 var STRICT_RULES = {
+  "@sarj/named-child-schema-type": "warn",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",