@sarj/eslint-plugin 19.0.2 → 19.4.0

package/dist/{chunk-KBGBBVAC.js → chunk-6RX5RU75.js}

@@ -4196,8 +4196,8 @@ function typeFacts(file, flags, roots, withMembers) {
     const indexes = facts.indexValueFlags.get(type) ?? [];
     return withMembers && (type.flags & flags.Object) !== 0 || indexes.length > 0 && indexes.every((index) => (index & flags.Unknown) !== 0);
   });
-  const properties = file.batch(counted.map((type) => checker.getPropertiesOfType.gen(type)));
-  counted.forEach((type, i) => facts.propertyCount.set(type, properties[i]?.length ?? 0));
+  const properties2 = file.batch(counted.map((type) => checker.getPropertiesOfType.gen(type)));
+  counted.forEach((type, i) => facts.propertyCount.set(type, properties2[i]?.length ?? 0));
   return facts;
 }
 var no_broad_return_type_default = defineRule({
@@ -4238,7 +4238,7 @@ var no_broad_return_type_default = defineRule({
         ...canFix && { fix: (fixer) => fixer.replaceText(annotation, sourceCode2.getText(annotation).replace(/[^\r\n]/gu, "")) }
       });
     }
-    function resolve3(file) {
+    function resolve4(file) {
       const flags = file.flags;
       const annotationTypes = valueTypes(file, flags, annotated.map((frame) => frame.annotation.typeAnnotation));
       const present = annotationTypes.filter((type) => type !== void 0);
@@ -4285,7 +4285,7 @@ var no_broad_return_type_default = defineRule({
       },
       "Program:exit"() {
         if (annotated.length === 0 || tsrs === null) return;
-        const reported = tsrs.run(resolve3);
+        const reported = tsrs.run(resolve4);
         if (reported === null) return;
         reported.forEach(report2);
       }
@@ -5166,10 +5166,10 @@ function overloadProof(file) {
     const node = unparen(expression);
     const literal2 = primitiveLiteral3(node);
     if (literal2 !== void 0) return { kind: "literal", node, value: literal2 };
-    const properties = node["properties"] ?? [];
-    if (!a.isObjectLiteralExpression(node) || properties.length > LIMIT) return void 0;
+    const properties2 = node["properties"] ?? [];
+    if (!a.isObjectLiteralExpression(node) || properties2.length > LIMIT) return void 0;
     const values = /* @__PURE__ */ new Map();
-    for (const property of properties) {
+    for (const property of properties2) {
       if (!a.isPropertyAssignment(property)) return void 0;
       const name = propertyKey(property["name"]);
       const value = primitiveLiteral3(property["initializer"]);
@@ -5848,10 +5848,10 @@ var no_cors_wildcard_with_credentials_default = defineRule({
       },
       ObjectExpression(node) {
         if (spreadOnly(node)) return;
-        const properties = effectiveProperties(node);
-        if (properties === null) return;
+        const properties2 = effectiveProperties(node);
+        if (properties2 === null) return;
         const headers = /* @__PURE__ */ new Map();
-        for (const [key, property] of properties) {
+        for (const [key, property] of properties2) {
           const value = headerValue(property.value);
           if (value === null) return;
           const name = key.toLowerCase();
@@ -5910,9 +5910,9 @@ function headerWrite(node) {
 function wildcardCredentialedOptions(argument) {
   if (argument === void 0) return false;
   const options = unwrapExpression(argument);
-  const properties = options.type === "ObjectExpression" ? effectiveProperties(options) : null;
-  const origin = properties?.get("origin");
-  const credentials = properties?.get("credentials");
+  const properties2 = options.type === "ObjectExpression" ? effectiveProperties(options) : null;
+  const origin = properties2?.get("origin");
+  const credentials = properties2?.get("credentials");
   if (origin === void 0 || credentials === void 0) return false;
   const value = unwrapExpression(credentials.value);
   return staticString(origin.value) === "*" && value.type === "Literal" && value.value === true;
@@ -5930,13 +5930,13 @@ function scalarLiteralText(node) {
   return value?.type === "Literal" && SCALAR_HEADER_VALUE_TYPES.has(typeof value.value) ? String(value.value) : null;
 }
 function effectiveProperties(node) {
-  const properties = /* @__PURE__ */ new Map();
+  const properties2 = /* @__PURE__ */ new Map();
   for (const entry of node.properties) {
     const entries = propertyEntries(entry);
     if (entries === null) return null;
-    for (const [key, property] of entries) properties.set(key, property);
+    for (const [key, property] of entries) properties2.set(key, property);
   }
-  return properties;
+  return properties2;
 }
 function propertyEntries(entry) {
   if (entry.type === "SpreadElement") {
@@ -6202,7 +6202,7 @@ function cookieName(value) {
 
 // src/utils/exported-next-config-property.ts
 function exportedNextConfigProperty(sourceCode2, path) {
-  const resolve3 = (input, seen = /* @__PURE__ */ new Set()) => {
+  const resolve4 = (input, seen = /* @__PURE__ */ new Set()) => {
     const node = unwrapExpression(input);
     if (node.type !== "Identifier") return node;
     if (seen.has(node)) return null;
@@ -6213,17 +6213,17 @@ function exportedNextConfigProperty(sourceCode2, path) {
     const declaration = definition.parent;
     const declarator = definition.node;
     if (declaration?.kind !== "const" || declarator.init === null || binding3?.references.some((reference) => reference.identifier !== node && reference.init !== true)) return null;
-    return resolve3(declarator.init, seen);
+    return resolve4(declarator.init, seen);
   };
   const exported = exportedConfig(sourceCode2);
   if (exported === null) return null;
-  let current = resolve3(exported);
+  let current = resolve4(exported);
   let selected = null;
   for (const name of path) {
     if (current?.type !== "ObjectExpression" || current.properties.some((property) => property.type !== "Property" || getPropertyName(property) === null || property.kind !== "init")) return null;
     selected = objectProperty(current, name);
     if (selected === null) return null;
-    current = resolve3(selected.value);
+    current = resolve4(selected.value);
   }
   return selected;
 }
@@ -8299,8 +8299,8 @@ var ActionResults = class {
         return error !== null && this.#closedError(error, owner);
       }
       case "ObjectExpression": {
-        const properties = this.#properties(value);
-        return properties !== null && [...properties.values()].some((field) => this.payload(field, owner, seen));
+        const properties2 = this.#properties(value);
+        return properties2 !== null && [...properties2.values()].some((field) => this.payload(field, owner, seen));
       }
       case "ArrayExpression":
         return !value.elements.some((element) => element?.type === "SpreadElement") && value.elements.some((element) => element !== null && this.payload(element, owner, seen));
@@ -8606,7 +8606,7 @@ var no_exception_text_in_5xx_response_default = defineRule({
       if (definition === void 0) return value.name === "Response" && stable2(variable);
       return variable.defs.length === 1 && isNextResponseImport(definition) && stable2(variable);
     }
-    function properties(node) {
+    function properties2(node) {
       const value = unwrapExpression(node);
       if (value.type !== "ObjectExpression") return null;
       const fields2 = /* @__PURE__ */ new Map();
@@ -8619,7 +8619,7 @@ var no_exception_text_in_5xx_response_default = defineRule({
       return fields2;
     }
     function serverError(node) {
-      const field = properties(node)?.get("status");
+      const field = properties2(node)?.get("status");
       const status = field === void 0 ? void 0 : unwrapExpression(field);
       return status?.type === "Literal" && typeof status.value === "number" && Number.isInteger(status.value) && status.value >= 500 && status.value <= 599;
     }
@@ -8631,7 +8631,7 @@ var no_exception_text_in_5xx_response_default = defineRule({
         case "MemberExpression":
           return exceptionTextErrors(value);
         case "ObjectExpression":
-          return [...properties(value)?.values() ?? []].flatMap(payloadErrors);
+          return [...properties2(value)?.values() ?? []].flatMap(payloadErrors);
         case "ArrayExpression":
           return arrayErrors(value);
         case "TemplateLiteral":
@@ -9248,8 +9248,8 @@ function parameterReads(native, parameter, body3, jsx, calls = false, auxiliarie
   const aliases = parameterAliases(native, parameter.name, reads);
   if (!aliases) return null;
   const expression = returnedExpression2(ast, body3);
-  const view = { native, props: checker.getTypeAtLocation(parameter), root, aliases, reads, calls, auxiliaries };
-  return expression && scalarView(expression, view, jsx) ? reads : null;
+  const view2 = { native, props: checker.getTypeAtLocation(parameter), root, aliases, reads, calls, auxiliaries };
+  return expression && scalarView(expression, view2, jsx) ? reads : null;
 }
 function scalarType(native, type, allowUndefined = true) {
   if (type.isUnionType()) return type.getTypes().every((part) => scalarType(native, part, allowUndefined));
@@ -9277,86 +9277,86 @@ function returnedExpression2(ast, body3) {
   const statement = body3.statements.length === 1 ? body3.statements[0] : void 0;
   return statement && ast.isReturnStatement(statement) ? statement.expression : void 0;
 }
-function scalarView(node, view, jsx = false) {
-  const { ast, checker } = view.native;
+function scalarView(node, view2, jsx = false) {
+  const { ast, checker } = view2.native;
   if (scalarLiteral(ast, node)) return true;
-  if (ast.isCallExpression(node)) return !jsx && scalarCall(node, view);
-  if (ast.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view, jsx));
+  if (ast.isCallExpression(node)) return !jsx && scalarCall(node, view2);
+  if (ast.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view2, jsx));
   if (ast.isIdentifier(node)) {
     const binding3 = checker.getSymbolAtLocation(node);
-    if (binding3 && view.auxiliaries?.has(binding3.id)) return scalarType(view.native, checker.getTypeAtLocation(node));
-    const key = binding3 && view.aliases.get(binding3.id);
-    return key !== void 0 && readField(node, key, view);
+    if (binding3 && view2.auxiliaries?.has(binding3.id)) return scalarType(view2.native, checker.getTypeAtLocation(node));
+    const key = binding3 && view2.aliases.get(binding3.id);
+    return key !== void 0 && readField(node, key, view2);
   }
-  if (ast.isPropertyAccessExpression(node) || ast.isElementAccessExpression(node)) return memberRead(node, view);
-  return scalarOperation(node, view, jsx);
+  if (ast.isPropertyAccessExpression(node) || ast.isElementAccessExpression(node)) return memberRead(node, view2);
+  return scalarOperation(node, view2, jsx);
 }
-function scalarOperation(node, view, jsx) {
-  const { ast } = view.native;
-  if (ast.isParenthesizedExpression(node) || ast.isNonNullExpression(node)) return scalarView(node.expression, view, jsx);
-  if (ast.isTypeOfExpression(node)) return scalarView(node.expression, view);
+function scalarOperation(node, view2, jsx) {
+  const { ast } = view2.native;
+  if (ast.isParenthesizedExpression(node) || ast.isNonNullExpression(node)) return scalarView(node.expression, view2, jsx);
+  if (ast.isTypeOfExpression(node)) return scalarView(node.expression, view2);
   if (ast.isConditionalExpression(node)) {
-    return scalarView(node.condition, view) && scalarView(node.whenTrue, view, jsx) && scalarView(node.whenFalse, view, jsx);
+    return scalarView(node.condition, view2) && scalarView(node.whenTrue, view2, jsx) && scalarView(node.whenFalse, view2, jsx);
   }
-  if (ast.isBinaryExpression(node)) return binaryView(node, view, jsx);
-  if (ast.isPrefixUnaryExpression(node)) return operatorKinds(ast).scalarPrefixes.has(node.operator) && scalarView(node.operand, view);
-  if (ast.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view));
-  return jsx && jsxView(node, view);
+  if (ast.isBinaryExpression(node)) return binaryView(node, view2, jsx);
+  if (ast.isPrefixUnaryExpression(node)) return operatorKinds(ast).scalarPrefixes.has(node.operator) && scalarView(node.operand, view2);
+  if (ast.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view2));
+  return jsx && jsxView(node, view2);
 }
-function scalarCall(node, view) {
-  const { ast, checker } = view.native;
+function scalarCall(node, view2) {
+  const { ast, checker } = view2.native;
   if (!ast.isCallExpression(node)) return false;
-  if (!view.calls || node.questionDotToken || node.typeArguments?.length || !ast.isIdentifier(node.expression) || !node.arguments.length || node.arguments.some((argument) => ast.isSpreadElement(argument))) return false;
+  if (!view2.calls || node.questionDotToken || node.typeArguments?.length || !ast.isIdentifier(node.expression) || !node.arguments.length || node.arguments.some((argument) => ast.isSpreadElement(argument))) return false;
   const declarations = checker.getSymbolAtLocation(node.expression)?.declarations;
   const handle = declarations?.length === 1 ? declarations[0] : void 0;
-  const declaration = handle && handle.path === node.getSourceFile().path ? declarationNode(view.native, handle) : void 0;
+  const declaration = handle && handle.path === node.getSourceFile().path ? declarationNode(view2.native, handle) : void 0;
   const helper = declaration && localHelper(ast, declaration);
-  if (!helper || helper.getSourceFile() !== node.getSourceFile() || helper.typeParameters?.length || !helper.type || !node.arguments.every((argument) => scalarView(argument, view))) return false;
-  if (!checkedNativeSource(view.native, node.getSourceFile())) return false;
+  if (!helper || helper.getSourceFile() !== node.getSourceFile() || helper.typeParameters?.length || !helper.type || !node.arguments.every((argument) => scalarView(argument, view2))) return false;
+  if (!checkedNativeSource(view2.native, node.getSourceFile())) return false;
   const signature = checker.getResolvedSignature(node);
-  const resolved = signature.declaration === void 0 ? void 0 : declarationNode(view.native, signature.declaration);
-  return resolved === helper && !checker.getTypePredicateOfSignature(signature) && scalarType(view.native, checker.getTypeAtLocation(node));
+  const resolved = signature.declaration === void 0 ? void 0 : declarationNode(view2.native, signature.declaration);
+  return resolved === helper && !checker.getTypePredicateOfSignature(signature) && scalarType(view2.native, checker.getTypeAtLocation(node));
 }
 function localHelper(ast, node) {
   if (ast.isFunctionDeclaration(node)) return node.body && ast.isSourceFile(node.parent) ? node : void 0;
   if (!ast.isVariableDeclaration(node) || node.type || !node.initializer || constInitializer2(ast, node) !== node.initializer || !ast.isArrowFunction(node.initializer) || !ast.isVariableStatement(node.parent.parent) || !ast.isSourceFile(node.parent.parent.parent)) return void 0;
   return node.initializer;
 }
-function binaryView(node, view, jsx) {
-  const { ast } = view.native;
+function binaryView(node, view2, jsx) {
+  const { ast } = view2.native;
   if (!ast.isBinaryExpression(node)) return false;
   const { scalarOperators, returnedOperands: returned2 } = operatorKinds(ast);
   const operands = jsx && returned2.has(node.operatorToken.kind);
-  return scalarOperators.has(node.operatorToken.kind) && scalarView(node.left, view, operands) && scalarView(node.right, view, operands);
+  return scalarOperators.has(node.operatorToken.kind) && scalarView(node.left, view2, operands) && scalarView(node.right, view2, operands);
 }
 function scalarLiteral(ast, node) {
   const k = ast.SyntaxKind;
   return ast.isStringLiteralLikeNode(node) || ast.isNumericLiteral(node) || ast.isBigIntLiteral(node) || ast.isJsxText(node) || node.kind === k.TrueKeyword || node.kind === k.FalseKeyword || node.kind === k.NullKeyword;
 }
-function memberRead(node, view) {
-  const { ast, checker } = view.native;
+function memberRead(node, view2) {
+  const { ast, checker } = view2.native;
   if (!ast.isPropertyAccessExpression(node) && !ast.isElementAccessExpression(node)) return false;
-  if (!view.root || !ast.isIdentifier(node.expression) || checker.getSymbolAtLocation(node.expression)?.id !== view.root.id) return false;
+  if (!view2.root || !ast.isIdentifier(node.expression) || checker.getSymbolAtLocation(node.expression)?.id !== view2.root.id) return false;
   const key = ast.isPropertyAccessExpression(node) ? ast.isIdentifier(node.name) ? node.name.text : void 0 : node.argumentExpression && (ast.isStringLiteralLikeNode(node.argumentExpression) || ast.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
-  return key !== void 0 && readField(node, key, view);
+  return key !== void 0 && readField(node, key, view2);
 }
-function readField(node, key, view) {
-  const { checker } = view.native;
-  if (!checker.getPropertyOfType(view.props, key) || !scalarType(view.native, checker.getTypeAtLocation(node))) return false;
-  view.reads.add(key);
+function readField(node, key, view2) {
+  const { checker } = view2.native;
+  if (!checker.getPropertyOfType(view2.props, key) || !scalarType(view2.native, checker.getTypeAtLocation(node))) return false;
+  view2.reads.add(key);
   return true;
 }
-function jsxView(node, view) {
-  const { ast } = view.native;
-  if (ast.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view, true));
-  if (ast.isJsxElement(node)) return jsxView(node.openingElement, view) && node.children.every((child) => scalarView(child, view, true));
+function jsxView(node, view2) {
+  const { ast } = view2.native;
+  if (ast.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view2, true));
+  if (ast.isJsxElement(node)) return jsxView(node.openingElement, view2) && node.children.every((child) => scalarView(child, view2, true));
   if (!ast.isJsxOpeningElement(node) && !ast.isJsxSelfClosingElement(node)) return false;
   if (!ast.isIdentifier(node.tagName) || !/^[a-z][A-Za-z0-9]*$/u.test(node.tagName.text)) return false;
-  return node.attributes.properties.every((attribute) => intrinsicAttribute(attribute, view));
+  return node.attributes.properties.every((attribute) => intrinsicAttribute(attribute, view2));
 }
-function intrinsicAttribute(attribute, view) {
-  const { ast } = view.native;
-  return ast.isJsxAttribute(attribute) && ast.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view));
+function intrinsicAttribute(attribute, view2) {
+  const { ast } = view2.native;
+  return ast.isJsxAttribute(attribute) && ast.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view2));
 }
 
 // src/utils/private-scalar-consumer.ts
@@ -11617,8 +11617,8 @@ var no_hand_rolled_spinner_default = defineRule({
           base: tailwindBase(token),
           variant: tailwindVariantPrefix(token)
         }));
-        const variants = new Set(classes.map((entry) => entry.variant));
-        if ([...variants].some((variant) => hasSpinnerInVariant(classes, variant))) {
+        const variants2 = new Set(classes.map((entry) => entry.variant));
+        if ([...variants2].some((variant) => hasSpinnerInVariant(classes, variant))) {
           context.report({ node, messageId: "handRolledSpinner" });
         }
       }
@@ -12295,9 +12295,9 @@ function localDataTarget(target, sourceCode2) {
   if (binding3 === null) return void 0;
   const value = annotatedLocalObject(binding3);
   if (value === void 0) return void 0;
-  const properties = plainProperties(value);
-  if (properties === void 0 || !onlyOwnerUses(binding3, value, sourceCode2)) return void 0;
-  return new Set(properties.map((property) => property.key));
+  const properties2 = plainProperties(value);
+  if (properties2 === void 0 || !onlyOwnerUses(binding3, value, sourceCode2)) return void 0;
+  return new Set(properties2.map((property) => property.key));
 }
 function annotatedLocalObject(binding3) {
   const definition = binding3.defs.length === 1 ? binding3.defs[0] : void 0;
@@ -12335,8 +12335,8 @@ function keepsMutableDescriptor(call, method) {
   if (method !== "defineProperty") return true;
   const descriptor = call.arguments[2];
   if (descriptor?.type !== "ObjectExpression") return false;
-  const properties = plainProperties(descriptor);
-  return properties !== void 0 && properties.every((property) => {
+  const properties2 = plainProperties(descriptor);
+  return properties2 !== void 0 && properties2.every((property) => {
     if (property.key !== "writable" && property.key !== "configurable") return true;
     const value = unwrapExpression(property.value);
     return value.type === "Literal" && value.value === true;
@@ -12395,9 +12395,9 @@ function mutationWrites(node, namespace, method) {
 }
 function dataDescriptorValue(descriptor) {
   if (descriptor.type !== "ObjectExpression") return void 0;
-  const properties = plainProperties(descriptor);
-  if (properties === void 0 || properties.some((property) => !DATA_DESCRIPTOR_KEYS.has(property.key))) return void 0;
-  return properties.find((property) => property.key === "value")?.value;
+  const properties2 = plainProperties(descriptor);
+  if (properties2 === void 0 || properties2.some((property) => !DATA_DESCRIPTOR_KEYS.has(property.key))) return void 0;
+  return properties2.find((property) => property.key === "value")?.value;
 }
 function plainProperties(node) {
   const writes2 = [];
@@ -12583,16 +12583,16 @@ function primitiveLiteral2(node) {
   if (typeof operand.value === "number") return value.operator === "-" ? -operand.value : operand.value;
   return typeof operand.value === "bigint" && value.operator === "-" ? -operand.value : void 0;
 }
-function primitiveDomain(view, flags) {
-  if (view.members !== void 0) return view.members.every((member3) => primitiveDomain({ type: member3, members: void 0 }, flags));
-  const type = view.type;
+function primitiveDomain(view2, flags) {
+  if (view2.members !== void 0) return view2.members.every((member3) => primitiveDomain({ type: member3, members: void 0 }, flags));
+  const type = view2.type;
   if ((type.flags & (flags.Enum | flags.EnumLiteral)) !== 0) return false;
   const domain = flags.String | flags.Number | flags.BigInt | flags.BooleanLiteral | flags.StringLiteral | flags.NumberLiteral | flags.BigIntLiteral | flags.Null | flags.Undefined | flags.Never;
   return (type.flags & domain) !== 0;
 }
-function acceptsPrimitive(view, value, flags) {
-  if (view.members !== void 0) return view.members.some((member3) => acceptsPrimitive({ type: member3, members: void 0 }, value, flags));
-  const type = view.type;
+function acceptsPrimitive(view2, value, flags) {
+  if (view2.members !== void 0) return view2.members.some((member3) => acceptsPrimitive({ type: member3, members: void 0 }, value, flags));
+  const type = view2.type;
   if (value === null) return (type.flags & flags.Null) !== 0;
   if (typeof value === "string") return (type.flags & flags.String) !== 0 || (type.flags & flags.StringLiteral) !== 0 && type.value === value;
   if (typeof value === "number") return (type.flags & flags.Number) !== 0 || (type.flags & flags.NumberLiteral) !== 0 && type.value === value;
@@ -12615,7 +12615,7 @@ var no_invalid_zod_custom_parse_default = defineRule({
     let tsrs = null;
     let strictNullChecks = false;
     let candidates2 = [];
-    function resolve3(file) {
+    function resolve4(file) {
       const flags = file.flags;
       const checker = file.checker;
       const pairs = candidates2.map((candidate2) => [file.tsNode(candidate2.custom), file.tsNode(candidate2.node)]);
@@ -12636,8 +12636,8 @@ var no_invalid_zod_custom_parse_default = defineRule({
       const reported = kept.flatMap((candidate2, i) => {
         const type = types[i];
         if (type === void 0) return [];
-        const view = { type, members: membersOf2.get(type) };
-        return !primitiveDomain(view, flags) || acceptsPrimitive(view, candidate2.value, flags) ? [] : [{ node: candidate2.node, type }];
+        const view2 = { type, members: membersOf2.get(type) };
+        return !primitiveDomain(view2, flags) || acceptsPrimitive(view2, candidate2.value, flags) ? [] : [{ node: candidate2.node, type }];
       });
       const names = file.batch(reported.map((entry) => file.checker.typeToString.gen(entry.type)));
       return reported.map((entry, i) => ({ node: entry.node, target: names[i] ?? "" }));
@@ -12663,7 +12663,7 @@ var no_invalid_zod_custom_parse_default = defineRule({
       },
       "Program:exit"() {
         if (candidates2.length === 0 || tsrs === null) return;
-        const reports = tsrs.run(resolve3);
+        const reports = tsrs.run(resolve4);
         if (reports === null) return;
         for (const { node, target } of reports) context.report({ node, messageId: "incompatibleCustomParse", data: { target } });
       }
@@ -13938,7 +13938,7 @@ function tsrsMembers(file, nodes) {
     if ((type.flags & table2.bigIntLiteral) !== 0) return BigInt(type.value) !== 0n;
     return void 0;
   }
-  return views.map((view) => view?.map((type) => ({ ...leaf(type), parts: partsOf2.get(type)?.map(leaf) })));
+  return views.map((view2) => view2?.map((type) => ({ ...leaf(type), parts: partsOf2.get(type)?.map(leaf) })));
 }
 function tsrsTable(flags) {
   return {
@@ -14003,20 +14003,20 @@ var no_logical_or_fallback_default = defineRule({
     function shadowed(node) {
       return (findVariable(context.sourceCode.getScope(node), node.name)?.defs.length ?? 0) !== 0;
     }
-    function resolve3(file) {
+    function resolve4(file) {
       const members2 = tsrsMembers(file, candidates2.map((candidate2) => candidate2.node.left));
-      const typed = members2.map((view) => view !== void 0 && fallbackType(view));
+      const typed = members2.map((view2) => view2 !== void 0 && fallbackType(view2));
       const pending = candidates2.flatMap((candidate2, i) => typed[i] === true && candidate2.callee !== null ? [i] : []);
       const identifiers = pending.flatMap((i) => candidates2[i].callee.identifier ?? []);
       const receivers = pending.flatMap((i) => candidates2[i].callee.receiver ?? []);
       const identifierSymbols = file.symbolsOf(identifiers);
       const receiverTypes = file.typesOf(receivers);
       const present = receiverTypes.filter((type) => type !== void 0);
-      const properties = file.batch(present.map((type) => type.getProperty.gen("Boolean")));
+      const properties2 = file.batch(present.map((type) => type.getProperty.gen("Boolean")));
       const symbolOf = /* @__PURE__ */ new Map();
       identifiers.forEach((node, i) => symbolOf.set(node, identifierSymbols[i]));
       let next = 0;
-      receivers.forEach((node, i) => symbolOf.set(node, receiverTypes[i] === void 0 ? void 0 : properties[next++]));
+      receivers.forEach((node, i) => symbolOf.set(node, receiverTypes[i] === void 0 ? void 0 : properties2[next++]));
       for (const i of pending) {
         const callee = candidates2[i].callee;
         if (file.isDefaultLibrarySymbol(symbolOf.get(callee.identifier ?? callee.receiver))) typed[i] = false;
@@ -14039,7 +14039,7 @@ var no_logical_or_fallback_default = defineRule({
       },
       "Program:exit"() {
         if (tsrs === null || candidates2.length === 0) return;
-        const found = tsrs.run(resolve3);
+        const found = tsrs.run(resolve4);
         if (found === null) return;
         candidates2.forEach((candidate2, i) => {
           if (found[i] === true) context.report({ node: candidate2.node, messageId: "logicalOrFallback" });
@@ -15053,18 +15053,18 @@ function labeledTupleObjectFix(sourceCode2, annotation) {
     return null;
   const pattern = callerPattern(sourceCode2, caller, helper, fields2);
   if (pattern === null) return null;
-  const properties = [];
+  const properties2 = [];
   for (const [index, label] of fields2.labels.entries()) {
     const value = fields2.values[index];
     if (value === void 0) return null;
-    properties.push(
+    properties2.push(
       `${sourceCode2.getText(label)}: ${sourceCode2.getText(value)}`
     );
   }
   const bindings = fields2.labels.map((label) => sourceCode2.getText(label));
   return (fixer) => [
     fixer.replaceText(annotation, sourceCode2.getText(object)),
-    fixer.replaceText(fields2.returned, `{ ${properties.join(", ")} }`),
+    fixer.replaceText(fields2.returned, `{ ${properties2.join(", ")} }`),
     fixer.replaceText(pattern, `{ ${bindings.join(", ")} }`)
   ];
 }
@@ -15925,12 +15925,12 @@ function renderFunction(node) {
   while (parent !== null) {
     const owner = functionNode2(parent);
     if (owner !== null) {
-      let view = VIEWS.get(owner);
-      if (view === void 0) {
-        view = owner.body !== null && containsView(owner.body);
-        VIEWS.set(owner, view);
+      let view2 = VIEWS.get(owner);
+      if (view2 === void 0) {
+        view2 = owner.body !== null && containsView(owner.body);
+        VIEWS.set(owner, view2);
       }
-      return view ? owner : null;
+      return view2 ? owner : null;
     }
     parent = parentOf(parent);
   }
@@ -18894,10 +18894,10 @@ function isNonzeroNumericLiteral(node) {
 function isPromiseSleep(node) {
   const executor = promiseExecutor(node);
   const body3 = executor?.body ?? null;
-  const resolve3 = executor?.params[0];
-  if (body3 === null || executor?.params.length !== 1 || resolve3?.type !== "Identifier" || resolve3.name === "setTimeout") return false;
+  const resolve4 = executor?.params[0];
+  if (body3 === null || executor?.params.length !== 1 || resolve4?.type !== "Identifier" || resolve4.name === "setTimeout") return false;
   const timer = executorTimer(body3);
-  return timer?.type === "CallExpression" && isTimedSetTimeout(timer) && timer.arguments[0]?.type === "Identifier" && timer.arguments[0].name === resolve3.name;
+  return timer?.type === "CallExpression" && isTimedSetTimeout(timer) && timer.arguments[0]?.type === "Identifier" && timer.arguments[0].name === resolve4.name;
 }
 function promiseExecutor(node) {
   const callee = unwrapExpression(node.callee);
@@ -20873,11 +20873,11 @@ var no_unsafe_mock_casting_default = defineRule({
   createOnce(context) {
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve3(identifier) {
+    function resolve4(identifier) {
       return typeBinding(context.sourceCode, identifier);
     }
     function record(identifier, destination) {
-      const binding3 = resolve3(identifier);
+      const binding3 = resolve4(identifier);
       if (binding3 !== null) destination.add(binding3);
     }
     function checkAssertion(node) {
@@ -20891,11 +20891,11 @@ var no_unsafe_mock_casting_default = defineRule({
       if (node.type !== "TSTypeReference") return false;
       const typeName = node.typeName;
       if (typeName.type === "Identifier") {
-        const binding3 = resolve3(typeName);
+        const binding3 = resolve4(typeName);
         return binding3 !== null && directBindings.has(binding3);
       }
       if (typeName.type === "TSQualifiedName" && typeName.left.type === "Identifier" && MOCK_TYPE_NAMES.has(typeName.right.name)) {
-        const binding3 = resolve3(typeName.left);
+        const binding3 = resolve4(typeName.left);
         return binding3 !== null && namespaceBindings.has(binding3);
       }
       return false;
@@ -21178,7 +21178,7 @@ function knownValue(env, type, location, seen) {
   if ((type.flags & flags.Object) === 0) return true;
   if (seen.has(type.id)) return true;
   if (seen.size >= 128) return false;
-  const [calls, constructs, array, properties, indexes] = ask(file, sync.all(
+  const [calls, constructs, array, properties2, indexes] = ask(file, sync.all(
     type.getCallSignatures.gen(),
     type.getConstructSignatures.gen(),
     checker.isArrayType.gen(type),
@@ -21195,8 +21195,8 @@ function knownValue(env, type, location, seen) {
     const element = type.getNumberIndexType();
     return element !== void 0 && knownValue(env, element, location, seen);
   }
-  if (properties.length + indexes.length === 0 || properties.length > 128) return false;
-  const types = file.batch(properties.map((property) => checker.getTypeOfSymbolAtLocation.gen(property, location)));
+  if (properties2.length + indexes.length === 0 || properties2.length > 128) return false;
+  const types = file.batch(properties2.map((property) => checker.getTypeOfSymbolAtLocation.gen(property, location)));
   return types.every((member3) => knownValue(env, member3, location, seen)) && indexes.every((index) => knownValue(env, index.valueType, location, seen));
 }
 function ask(file, request) {
@@ -21249,7 +21249,7 @@ function sameShape(env, input, output, location) {
     return (member3.flags & (flags.Object | opaque)) === 0 && others.some((other) => other.id === member3.id);
   }
   function sameObjectShape(left, right) {
-    const [leftTuple, rightTuple, leftArray, rightArray, properties, rightProperties] = ask(file, sync.all(
+    const [leftTuple, rightTuple, leftArray, rightArray, properties2, rightProperties] = ask(file, sync.all(
       checker.isTupleType.gen(left),
       checker.isTupleType.gen(right),
       checker.isArrayType.gen(left),
@@ -21259,17 +21259,17 @@ function sameShape(env, input, output, location) {
     ));
     if (leftTuple || rightTuple) return leftTuple && rightTuple && sameTuplePositions(left, right);
     if (leftArray) return rightArray && sameArrayElements(left, right);
-    return properties.length === rightProperties.length && properties.length <= 128 && sameProperties(right, properties) && sameIndexInfos(left, right);
+    return properties2.length === rightProperties.length && properties2.length <= 128 && sameProperties(right, properties2) && sameIndexInfos(left, right);
   }
   function sameArrayElements(left, right) {
     const a = left.getNumberIndexType();
     const b = right.getNumberIndexType();
     return a !== void 0 && b !== void 0 && compare(a, b);
   }
-  function sameProperties(right, properties) {
-    const others = file.batch(properties.map((property) => right.getProperty.gen(property.name)));
+  function sameProperties(right, properties2) {
+    const others = file.batch(properties2.map((property) => right.getProperty.gen(property.name)));
     const matched = [];
-    for (const [i, property] of properties.entries()) {
+    for (const [i, property] of properties2.entries()) {
       const other = others[i];
       if (other === void 0) break;
       matched.push([property, other]);
@@ -21280,7 +21280,7 @@ function sameShape(env, input, output, location) {
       const b = types[2 * i + 1];
       if (a === void 0 || b === void 0 || !compare(a, b)) return false;
     }
-    return matched.length === properties.length;
+    return matched.length === properties2.length;
   }
   function sameIndexInfos(left, right) {
     const a = checker.getIndexInfosOfType(left);
@@ -21315,7 +21315,7 @@ var no_zod_parse_typed_object_default = defineRule({
   createOnce(context) {
     let tsrs = null;
     let candidates2 = [];
-    function resolve3(native) {
+    function resolve4(native) {
       const flags = native.sync.TypeFlags;
       const env = {
         native,
@@ -21355,7 +21355,7 @@ var no_zod_parse_typed_object_default = defineRule({
       },
       "Program:exit"() {
         if (candidates2.length === 0 || tsrs === null) return;
-        const found = tsrs.run((file) => resolve3(nativeTypes(file)));
+        const found = tsrs.run((file) => resolve4(nativeTypes(file)));
         if (found === null) return;
         candidates2.forEach((candidate2, i) => {
           if (found[i] === true) context.report({ node: candidate2.node, messageId: "typedObject" });
@@ -21499,8 +21499,334 @@ var prefer_await_in_async_return_default = defineRule({
   }
 });
 
+// src/rules/prefer-coded-error-result.ts
+var NAME91 = "prefer-coded-error-result";
+var MAX_DEPTH = 16;
+var MAX_VARIANTS = 64;
+var MAX_TYPE_STEPS = 256;
+var STATUS_NAMES = ["ok", "success"];
+var CODE_NAMES = ["code", "kind", "type", "tag"];
+function view(node) {
+  return { node, origin: node, bindings: /* @__PURE__ */ new Map() };
+}
+function resolve2(value, source, depth = 0) {
+  if (depth >= MAX_DEPTH) return null;
+  const node = value.node;
+  if (node.type !== "TSTypeReference") return value;
+  if (node.typeName.type !== "Identifier") return null;
+  const variable = typeBinding(source, node.typeName);
+  if (variable === null) return null;
+  const bound = value.bindings.get(variable);
+  if (bound !== void 0) return resolve2(bound, source, depth + 1);
+  const declaration = variable.defs.length === 1 ? variable.defs[0]?.node : void 0;
+  if (declaration?.type !== "TSTypeAliasDeclaration" && declaration?.type !== "TSInterfaceDeclaration")
+    return null;
+  if (declaration.type === "TSInterfaceDeclaration" && declaration.extends.length !== 0)
+    return null;
+  const bindings = bindArguments(declaration, node, value, source);
+  if (bindings === null) return null;
+  return resolve2(
+    {
+      node: declaration.type === "TSTypeAliasDeclaration" ? declaration.typeAnnotation : declaration.body,
+      origin: value.origin,
+      bindings
+    },
+    source,
+    depth + 1
+  );
+}
+function bindArguments(declaration, reference, outer, source) {
+  const parameters = declaration.typeParameters?.params ?? [];
+  const arguments_ = reference.typeArguments?.params ?? [];
+  if (arguments_.length > parameters.length) return null;
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [index, parameter] of parameters.entries()) {
+    const variable = typeBinding(source, parameter.name);
+    if (variable === null) return null;
+    const argument = arguments_[index];
+    if (argument !== void 0)
+      bindings.set(variable, {
+        node: argument,
+        origin: argument,
+        bindings: outer.bindings
+      });
+    else if (parameter.default !== null)
+      bindings.set(variable, {
+        node: parameter.default,
+        origin: reference,
+        bindings
+      });
+  }
+  return bindings;
+}
+function properties(value) {
+  const node = value.node;
+  const members2 = node.type === "TSTypeLiteral" ? node.members : node.type === "TSInterfaceBody" ? node.body : null;
+  if (members2 === null) return null;
+  const result = /* @__PURE__ */ new Map();
+  for (const member3 of members2) {
+    if (member3.type !== "TSPropertySignature" || member3.computed || member3.typeAnnotation === null)
+      return null;
+    const name = member3.key.type === "Identifier" ? member3.key.name : member3.key.type === "Literal" && typeof member3.key.value === "string" ? member3.key.value : null;
+    if (name === null || result.has(name)) return null;
+    result.set(name, member3);
+  }
+  return result;
+}
+function propertyView(property, owner) {
+  const node = property.typeAnnotation?.typeAnnotation;
+  return node === void 0 ? null : { node, origin: node, bindings: owner.bindings };
+}
+function booleanTag(property, owner, source) {
+  if (property === void 0 || property.optional) return null;
+  const type = propertyView(property, owner);
+  const resolved = type === null ? null : resolve2(type, source);
+  const node = resolved?.node;
+  return node?.type === "TSLiteralType" && node.literal.type === "Literal" && typeof node.literal.value === "boolean" ? node.literal.value : null;
+}
+function hasCode(fields2, owner, source) {
+  return CODE_NAMES.some((name) => {
+    const property = fields2.get(name);
+    if (property === void 0 || property.optional) return false;
+    const type = propertyView(property, owner);
+    return type !== null && openString(type, source) === null;
+  });
+}
+function openString(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (depth >= MAX_DEPTH || --budget.remaining < 0) return null;
+  const resolved = resolve2(value, source);
+  if (resolved === null) return null;
+  if (resolved.node.type === "TSStringKeyword") return resolved.origin;
+  if (resolved.node.type !== "TSUnionType" || resolved.node.types.length > MAX_VARIANTS)
+    return null;
+  for (const member3 of resolved.node.types) {
+    const broad = openString(
+      { ...resolved, node: member3 },
+      source,
+      depth + 1,
+      budget
+    );
+    if (broad !== null) return broad;
+  }
+  return null;
+}
+function weakError(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (depth >= MAX_DEPTH || --budget.remaining < 0) return null;
+  const resolved = resolve2(value, source);
+  if (resolved === null) return null;
+  if (resolved.node.type === "TSStringKeyword") return resolved.origin;
+  if (resolved.node.type === "TSUnionType") {
+    if (resolved.node.types.length > MAX_VARIANTS) return null;
+    for (const member3 of resolved.node.types) {
+      const error = weakError(
+        { ...resolved, node: member3 },
+        source,
+        depth + 1,
+        budget
+      );
+      if (error !== null) return error;
+    }
+    return null;
+  }
+  const fields2 = properties(resolved);
+  if (fields2 === null || hasCode(fields2, resolved, source)) return null;
+  return weakObject(fields2, resolved, source, depth, budget);
+}
+function weakObject(fields2, owner, source, depth, budget) {
+  const code = openStringField(fields2, owner, source, CODE_NAMES, budget);
+  if (code !== null) return code;
+  const error = fields2.get("error");
+  if (error !== void 0) {
+    const inner = propertyView(error, owner);
+    return inner === null || error.optional ? null : weakError(inner, source, depth + 1, budget);
+  }
+  return openStringField(fields2, owner, source, ["message", "reason"], budget);
+}
+function openStringField(fields2, owner, source, names, budget) {
+  for (const name of names) {
+    const property = fields2.get(name);
+    if (property === void 0 || property.optional) continue;
+    const inner = propertyView(property, owner);
+    const broad = inner === null ? null : openString(inner, source, 0, budget);
+    if (broad !== null) return broad;
+  }
+  return null;
+}
+function failureMessages(value, source) {
+  const members2 = variants(value, source);
+  if (members2 === null || members2.length < 2) return [];
+  const objects = members2.map((member3) => ({
+    member: member3,
+    fields: properties(member3)
+  }));
+  if (objects.some((object) => object.fields === null)) return [];
+  for (const status of STATUS_NAMES) {
+    const tags = objects.map(
+      (object) => booleanTag(object.fields?.get(status), object.member, source)
+    );
+    if (tags.some((tag) => tag === null) || !tags.includes(true) || !tags.includes(false))
+      continue;
+    if (objects.some(
+      (object, index) => tags[index] === true && ["error", "errors"].some((name) => object.fields?.has(name))
+    ))
+      continue;
+    return objects.flatMap((object, index) => {
+      if (tags[index] !== false || object.fields === null || hasCode(object.fields, object.member, source))
+        return [];
+      if (["data", "value", "result"].some((name) => object.fields?.has(name)))
+        return [];
+      const error = weakError(object.member, source);
+      return error === null ? [] : [error];
+    });
+  }
+  return [];
+}
+function variants(value, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (--budget.remaining < 0) return null;
+  const resolved = resolve2(value, source);
+  if (resolved === null || depth >= MAX_DEPTH) return null;
+  if (resolved.node.type !== "TSUnionType") return [resolved];
+  const result = [];
+  for (const member3 of resolved.node.types) {
+    const nested = variants(
+      { ...resolved, node: member3, origin: member3 },
+      source,
+      depth + 1,
+      budget
+    );
+    if (nested === null || result.length + nested.length > MAX_VARIANTS)
+      return null;
+    result.push(...nested);
+  }
+  return result;
+}
+function libraryError(reference, source) {
+  if (reference.typeName.type !== "Identifier" || reference.typeArguments?.params.length !== 2)
+    return null;
+  const variable = typeBinding(source, reference.typeName);
+  const definition = variable?.defs.length === 1 ? variable.defs[0]?.node : void 0;
+  if (definition?.type !== "ImportSpecifier") return null;
+  const declaration = parentOf(definition);
+  if (declaration?.type !== "ImportDeclaration" || declaration.source.value !== "neverthrow")
+    return null;
+  if (!["Result", "ResultAsync"].includes(importSpecifierName(definition) ?? ""))
+    return null;
+  const error = reference.typeArguments.params[1];
+  return error === void 0 ? null : weakError(view(error), source);
+}
+function weakAnnotation(node, source, depth = 0, budget = { remaining: MAX_TYPE_STEPS }) {
+  if (depth >= MAX_DEPTH || --budget.remaining < 0) return false;
+  if (failureMessages(view(node), source).length !== 0) return true;
+  if (node.type !== "TSTypeReference") return false;
+  if (libraryError(node, source) !== null) return true;
+  if (node.typeName.type !== "Identifier" || !["Promise", "PromiseLike"].includes(node.typeName.name) || typeBinding(source, node.typeName) !== null || node.typeArguments?.params.length !== 1)
+    return false;
+  const argument = node.typeArguments.params[0];
+  return argument !== void 0 && weakAnnotation(argument, source, depth + 1, budget);
+}
+function renderedFailure(node) {
+  const outer = objectFields(unwrapExpression(node));
+  if (outer === null || !STATUS_NAMES.some((name) => {
+    const status = outer.get(name);
+    return status?.type === "Literal" && status.value === false;
+  }))
+    return null;
+  const error = outer.get("error");
+  const fields2 = error === void 0 ? outer : objectFields(unwrapExpression(error));
+  if (fields2 === null || !CODE_NAMES.some((name) => {
+    const code = fields2.get(name);
+    return code?.type === "Literal" && typeof code.value === "string";
+  }))
+    return null;
+  for (const name of ["message", "reason"]) {
+    const value = fields2.get(name);
+    if (value !== void 0 && renderedString(value)) return value;
+  }
+  return null;
+}
+function objectFields(node) {
+  if (node.type !== "ObjectExpression") return null;
+  const fields2 = /* @__PURE__ */ new Map();
+  for (const property of node.properties) {
+    if (property.type !== "Property" || property.computed || property.kind !== "init" || property.method)
+      return null;
+    const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" && typeof property.key.value === "string" ? property.key.value : null;
+    if (key === null || fields2.has(key)) return null;
+    fields2.set(key, property.value);
+  }
+  return fields2;
+}
+function renderedString(node, depth = 0) {
+  const value = unwrapExpression(node);
+  if (depth >= MAX_DEPTH) return false;
+  if (value.type === "TemplateLiteral") return value.expressions.length > 0;
+  if (value.type !== "BinaryExpression" || value.operator !== "+") return false;
+  return [value.left, value.right].some(
+    (part) => part.type === "Literal" && typeof part.value === "string" || renderedString(part, depth + 1)
+  );
+}
+var prefer_coded_error_result_default = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Return a stable error code and typed context instead of only a rendered failure message.",
+      url: docsUrl(NAME91)
+    },
+    schema: [],
+    messages: {
+      preferCodedErrorResult: "This Result failure carries only a rendered string or an open string code. Return a finite error code with the typed context needed by the caller, and format the message at the consumer. Keep an intentional presentation boundary explicit.",
+      formatAtConsumer: "This coded failure formats context into a message at the producer. Return the code and typed context, and let the consumer format the message. Preserve an intentional presentation boundary explicitly."
+    }
+  },
+  createOnce(context) {
+    const reported = /* @__PURE__ */ new Set();
+    function check(node) {
+      const candidates2 = failureMessages(view(node), context.sourceCode);
+      const library = node.type === "TSTypeReference" ? libraryError(node, context.sourceCode) : null;
+      for (const candidate2 of library === null ? candidates2 : [...candidates2, library]) {
+        if (reported.has(candidate2)) continue;
+        reported.add(candidate2);
+        context.report({
+          node: candidate2,
+          messageId: "preferCodedErrorResult"
+        });
+      }
+    }
+    function checkProducer(owner, value) {
+      if (owner === null) return;
+      const rendered = renderedFailure(value);
+      if (rendered === null || reported.has(rendered)) return;
+      const contract = owner.returnType?.typeAnnotation;
+      if (contract !== void 0 && weakAnnotation(contract, context.sourceCode))
+        return;
+      reported.add(rendered);
+      context.report({ node: rendered, messageId: "formatAtConsumer" });
+    }
+    return {
+      before() {
+        reported.clear();
+        if (isGeneratedFile(
+          { filename: context.filename, cwd: context.cwd },
+          context.sourceCode.text
+        ))
+          return false;
+        return void 0;
+      },
+      TSUnionType: check,
+      TSTypeReference: check,
+      ReturnStatement(node) {
+        if (node.argument !== null)
+          checkProducer(enclosingFunction(node), node.argument);
+      },
+      ArrowFunctionExpression(node) {
+        if (node.body.type !== "BlockStatement") checkProducer(node, node.body);
+      }
+    };
+  }
+});
+
 // src/rules/prefer-constant-time-secret-compare.ts
-var NAME91 = "prefer-constant-time-secret-compare";
+var NAME92 = "prefer-constant-time-secret-compare";
 var EQUALITY_OPERATORS3 = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var AUTH_TOKEN_QUALIFIERS = /* @__PURE__ */ new Set(["access", "refresh", "session", "admin", "csrf", "xsrf", "auth", "authentication", "signing", "api"]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
@@ -21564,7 +21890,7 @@ var prefer_constant_time_secret_compare_default = defineRule({
     type: "problem",
     docs: {
       description: "Prefer a supported constant-time comparison primitive for secret-like values.",
-      url: docsUrl(NAME91)
+      url: docsUrl(NAME92)
     },
     schema: [],
     messages: {
@@ -21652,7 +21978,7 @@ function constInitializer4(definition) {
 }
 
 // src/rules/prefer-dependency-interface.ts
-var NAME92 = "prefer-dependency-interface";
+var NAME93 = "prefer-dependency-interface";
 function readsInterfaceMember(use, members2) {
   const parent = parentOf(use);
   if (parent?.type !== "MemberExpression" || parent.object !== use || !members2.has(getPropertyName(parent) ?? "")) return false;
@@ -21682,7 +22008,7 @@ var prefer_dependency_interface_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Annotate retained collaborators with their existing interface when the consumer uses only that contract.",
-      url: docsUrl(NAME92)
+      url: docsUrl(NAME93)
     },
     schema: [],
     messages: { interface: "Use the existing `{{contract}}` interface for this dependency; its consumer uses only that contract." }
@@ -21773,11 +22099,43 @@ function discriminatedUnionReturns(node, sourceCode2) {
     if (member3.optional) continue;
     const domain = tagDomain(member3.typeAnnotation?.typeAnnotation);
     if (domain !== void 0 && hasTagSpecificPayload(name, domain, shape.optional, returned2)) {
-      return { reportNode: contract.reportNode, tag: name, members: shape.members, returned: returned2 };
+      return { reportNode: contract.reportNode, relationship: { kind: "presence", tag: name }, members: shape.members, returned: returned2 };
+    }
+  }
+  const fields2 = correlatedBooleanFields(shape, returned2);
+  return fields2 === void 0 ? void 0 : {
+    reportNode: contract.reportNode,
+    relationship: { kind: "boolean-pair", fields: fields2 },
+    members: shape.members,
+    returned: returned2
+  };
+}
+function correlatedBooleanFields(shape, returned2) {
+  const fields2 = [...shape.members].filter(([, member3]) => !member3.optional && member3.typeAnnotation?.typeAnnotation.type === "TSBooleanKeyword").map(([name]) => name);
+  if (fields2.length > 8) return void 0;
+  for (const [index, left] of fields2.entries()) {
+    for (const right of fields2.slice(index + 1)) {
+      const combinations = booleanCombinations(left, right, returned2);
+      if (combinations !== void 0 && restrictedVaryingPair(combinations)) return { left, right };
     }
   }
   return void 0;
 }
+function booleanCombinations(left, right, returned2) {
+  const combinations = /* @__PURE__ */ new Set();
+  for (const properties2 of returned2) {
+    const a = properties2.get(left);
+    const b = properties2.get(right);
+    if (a?.type !== "Literal" || typeof a.value !== "boolean" || b?.type !== "Literal" || typeof b.value !== "boolean") return void 0;
+    combinations.add(`${Number(a.value)}${Number(b.value)}`);
+  }
+  return combinations;
+}
+function restrictedVaryingPair(combinations) {
+  if (combinations.size < 2 || combinations.size === 4) return false;
+  const values = [...combinations];
+  return [0, 1].every((index) => values.some((value) => value[index] === "0") && values.some((value) => value[index] === "1"));
+}
 function returnContract(node, sourceCode2) {
   const annotation = node.returnType;
   if (!isPresent(annotation)) return void 0;
@@ -21822,33 +22180,33 @@ function objectContract(elements) {
     members2.set(name, member3);
     if (member3.optional) optional.add(name);
   }
-  return optional.size === 0 ? void 0 : { members: members2, optional };
+  return { members: members2, optional };
 }
 function returnedProperties(objects, contract) {
   const returned2 = [];
   for (const object of objects) {
-    const properties = objectProperties(object);
-    if (properties === void 0) return void 0;
-    if ([...properties.keys()].some((name) => !contract.members.has(name))) return void 0;
-    if ([...contract.members].some(([name, member3]) => !member3.optional && !properties.has(name))) return void 0;
-    if (hasEmptyPayload(properties, contract.optional)) return void 0;
-    returned2.push(properties);
+    const properties2 = objectProperties(object);
+    if (properties2 === void 0) return void 0;
+    if ([...properties2.keys()].some((name) => !contract.members.has(name))) return void 0;
+    if ([...contract.members].some(([name, member3]) => !member3.optional && !properties2.has(name))) return void 0;
+    if (hasEmptyPayload(properties2, contract.optional)) return void 0;
+    returned2.push(properties2);
   }
   return returned2;
 }
 function objectProperties(object) {
-  const properties = /* @__PURE__ */ new Map();
+  const properties2 = /* @__PURE__ */ new Map();
   for (const property of object.properties) {
     if (property.type !== "Property" || property.kind !== "init" || property.method) return void 0;
     const name = propertyName(property);
-    if (name === void 0 || name === "__proto__" || properties.has(name) || property.value.type === "AssignmentPattern") return void 0;
-    properties.set(name, property.value);
+    if (name === void 0 || name === "__proto__" || properties2.has(name) || property.value.type === "AssignmentPattern") return void 0;
+    properties2.set(name, property.value);
   }
-  return properties;
+  return properties2;
 }
-function hasEmptyPayload(properties, optional) {
+function hasEmptyPayload(properties2, optional) {
   for (const name of optional) {
-    const value = properties.get(name);
+    const value = properties2.get(name);
     if (value === void 0) continue;
     if (value.type === "Literal" && value.value === null) return true;
     if (value.type === "Identifier" && value.name === "undefined") return true;
@@ -21869,19 +22227,19 @@ function tagDomain(node) {
   return values.size > 1 ? values : void 0;
 }
 function hasTagSpecificPayload(tag, domain, optional, returned2) {
-  const variants = /* @__PURE__ */ new Map();
-  for (const properties of returned2) {
-    const value = properties.get(tag);
+  const variants2 = /* @__PURE__ */ new Map();
+  for (const properties2 of returned2) {
+    const value = properties2.get(tag);
     const literal2 = value === void 0 ? void 0 : literalTag(value);
     if (literal2 === void 0 || !domain.has(literal2)) return false;
-    const payload = new Set([...optional].filter((name) => properties.has(name)));
-    const previous = variants.get(literal2);
+    const payload = new Set([...optional].filter((name) => properties2.has(name)));
+    const previous = variants2.get(literal2);
     if (previous !== void 0 && (previous.size !== payload.size || [...previous].some((name) => !payload.has(name)))) return false;
-    variants.set(literal2, payload);
+    variants2.set(literal2, payload);
   }
-  if (variants.size !== domain.size) return false;
+  if (variants2.size !== domain.size) return false;
   return [...optional].some((name) => {
-    const presence = [...variants.values()].map((payload) => payload.has(name));
+    const presence = [...variants2.values()].map((payload) => payload.has(name));
     return presence.includes(true) && presence.includes(false);
   });
 }
@@ -22007,103 +22365,19 @@ function literalTag(node) {
 }
 
 // src/rules/prefer-discriminated-union.ts
-var NAME93 = "prefer-discriminated-union";
-var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "success",
-  "ok"
-]);
-var FAILURE_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "error",
-  "errors",
-  "reason",
-  "cause"
-]);
-var SUCCESS_PAYLOAD_MEMBER_NAMES = /* @__PURE__ */ new Set([
-  "data",
-  "events",
-  "payload",
-  "response",
-  "result",
-  "value"
-]);
-var REQUIRED_STATUS_MEMBER_COUNT = 1;
-var FUNCTION_RETURN_OWNER_TYPES = /* @__PURE__ */ new Set([
-  "ArrowFunctionExpression",
-  "FunctionDeclaration",
-  "FunctionExpression",
-  "TSDeclareFunction",
-  "TSEmptyBodyFunctionExpression",
-  "TSFunctionType",
-  "TSMethodSignature"
-]);
-function looksLikeMutuallyExclusiveState(typeLiteral) {
-  let statusMemberCount = 0;
-  let hasFailurePayload = false;
-  let hasSuccessPayload = false;
-  let hasUnrecognizedMember = false;
-  for (const member3 of typeLiteral.members) {
-    if (member3.type !== "TSPropertySignature") {
-      hasUnrecognizedMember = true;
-      continue;
-    }
-    const name = getMemberName(member3);
-    if (name !== null && STATUS_MEMBER_NAMES.has(name) && isBooleanTyped(member3) && !member3.optional) {
-      statusMemberCount += 1;
-      continue;
-    }
-    if (!member3.optional || isBooleanTyped(member3) || name === null) {
-      hasUnrecognizedMember = true;
-      continue;
-    }
-    if (FAILURE_MEMBER_NAMES.has(name)) {
-      hasFailurePayload = true;
-    } else if (SUCCESS_PAYLOAD_MEMBER_NAMES.has(name)) {
-      hasSuccessPayload = true;
-    } else {
-      hasUnrecognizedMember = true;
-    }
-  }
-  return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
-}
-function getMemberName(member3) {
-  if (member3.type !== "TSPropertySignature" || member3.computed) {
-    return null;
-  }
-  const { key } = member3;
-  if (key.type === "Identifier") {
-    return key.name;
-  }
-  if (key.type === "Literal" && typeof key.value === "string") {
-    return key.value;
-  }
-  return null;
-}
-function isBooleanTyped(member3) {
-  return member3.typeAnnotation?.typeAnnotation.type === "TSBooleanKeyword";
-}
-function inlineReturnTypeLiteral(node) {
-  let annotation = null;
-  if (node.parent.type === "TSTypeAnnotation") {
-    annotation = node.parent;
-  } else if (node.parent.type === "TSTypeParameterInstantiation" && node.parent.params.length === 1 && node.parent.params[0] === node && node.parent.parent.type === "TSTypeReference" && node.parent.parent.typeName.type === "Identifier" && node.parent.parent.typeName.name === "Promise" && node.parent.parent.parent.type === "TSTypeAnnotation") {
-    annotation = node.parent.parent.parent;
-  }
-  if (annotation === null) return null;
-  const owner = annotation.parent;
-  return FUNCTION_RETURN_OWNER_TYPES.has(owner.type) && "returnType" in owner && owner.returnType === annotation ? annotation : null;
-}
+var NAME94 = "prefer-discriminated-union";
 var prefer_discriminated_union_default = defineRule({
   meta: {
     type: "suggestion",
     fixable: "code",
     docs: {
-      description: "Prefer discriminated unions for result contracts and locally proven tag-specific return payloads.",
-      url: docsUrl(NAME93)
+      description: "Preserve producer-proven tag/payload and Boolean state relationships in return types.",
+      url: docsUrl(NAME94)
     },
     schema: [],
     messages: {
       preferProducedVariants: "This producer returns tag-specific payloads for `{{tag}}`, but its flat return contract makes them optional. If these variants define the domain, use a discriminated union with each variant's required payload, or give this producer a precise return type separate from the broader contract.",
-      preferDiscriminatedUnion: "This object type combines a boolean status with optional payloads. If success and failure are mutually exclusive, consider a discriminated union such as `{ ok: true; data: T } | { ok: false; error: E }`."
+      preferProducedState: "This producer returns a restricted set of literal combinations for `{{fields}}`, while its Boolean fields permit all four. Review a union preserving every returned combination, or a typed disposition if these are domain phases. Other writers and readers of a shared contract require review."
     }
   },
   createOnce(context) {
@@ -22117,30 +22391,13 @@ var prefer_discriminated_union_default = defineRule({
       if (result === void 0 || reportedContracts.has(result.reportNode)) return;
       reportedContracts.add(result.reportNode);
       const fix = privateVariantReturn(context.sourceCode, context.filename, node, result);
+      const relationship = result.relationship;
       context.report({
         node: result.reportNode,
-        messageId: "preferProducedVariants",
         ...fix !== null && { fix },
-        data: { tag: result.tag }
+        ...relationship.kind === "presence" ? { messageId: "preferProducedVariants", data: { tag: relationship.tag } } : { messageId: "preferProducedState", data: { fields: [relationship.fields.left, relationship.fields.right].join("`, `") } }
       });
     }
-    function checkTypeLiteral(typeLiteral, reportNode) {
-      if (looksLikeMutuallyExclusiveState(typeLiteral) && !reportedContracts.has(reportNode)) {
-        reportedContracts.add(reportNode);
-        const fix = inlineProducerFix(reportNode);
-        context.report({
-          node: reportNode,
-          messageId: "preferDiscriminatedUnion",
-          ...fix !== null && { fix }
-        });
-      }
-    }
-    function inlineProducerFix(reportNode) {
-      if (reportNode.type !== "TSTypeAnnotation" || reportNode.parent.type !== "FunctionDeclaration") return null;
-      const owner = reportNode.parent;
-      const result = discriminatedUnionReturns(owner, context.sourceCode);
-      return result === void 0 ? null : privateVariantReturn(context.sourceCode, context.filename, owner, result);
-    }
     return {
       before() {
         reportedContracts.clear();
@@ -22154,51 +22411,41 @@ var prefer_discriminated_union_default = defineRule({
       FunctionExpression: rememberProducer,
       "Program:exit"() {
         for (const producer of producers) checkProducer(producer);
-      },
-      TSInterfaceDeclaration(node) {
-        if (node.extends.length > 0) {
-          return;
-        }
-        checkTypeLiteral({ members: node.body.body }, node);
-      },
-      TSTypeLiteral(node) {
-        if (node.parent.type === "TSTypeAliasDeclaration") checkTypeLiteral(node, node.parent);
-        const annotation = inlineReturnTypeLiteral(node);
-        if (annotation !== null) checkTypeLiteral(node, annotation);
       }
     };
   }
 });
 function privateVariantReturn(sourceCode2, filename, owner, result) {
   const annotation = owner.returnType?.typeAnnotation;
-  if (owner.type !== "FunctionDeclaration" || owner.id === null || !returnsOnlyConditionalObject(owner) || annotation?.type !== "TSTypeLiteral" || result.reportNode !== owner.returnType || result.returned.length !== 2 || sourceCode2.getCommentsInside(owner).length > 0 || !isUnusedPrivateBinding(sourceCode2, owner, owner.id, filename) || !retainsNamedTypeUses(sourceCode2, annotation)) return null;
-  const variants = result.returned.map((properties) => privateVariantType(properties, result, sourceCode2));
-  if (variants.some((variant) => variant === null)) return null;
-  const text = `${variants.join(" | ")}${sourceCode2.getText(annotation).replace(/[^\r\n]/gu, "")}`;
+  if (owner.type !== "FunctionDeclaration" || owner.id === null || !returnsOnlyConditionalObject(owner) || annotation?.type !== "TSTypeLiteral" || result.reportNode !== owner.returnType || result.returned.length > 4 || sourceCode2.getCommentsInside(owner).length > 0 || !isUnusedPrivateBinding(sourceCode2, owner, owner.id, filename) || !retainsNamedTypeUses(sourceCode2, annotation)) return null;
+  const variants2 = result.returned.map((properties2) => privateVariantType(properties2, result, sourceCode2));
+  if (variants2.some((variant) => variant === null)) return null;
+  const text = `${variants2.join(" | ")}${sourceCode2.getText(annotation).replace(/[^\r\n\u2028\u2029]/gu, "")}`;
   return (fixer) => fixer.replaceText(annotation, text);
 }
 function returnsOnlyConditionalObject(fn) {
   if (fn.async || fn.generator || isPresent(fn.typeParameters)) return false;
   const statements = fn.body?.body ?? [];
   const [returned2] = statements;
-  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression" && returned2.argument.consequent.type === "ObjectExpression" && returned2.argument.alternate.type === "ObjectExpression";
+  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression";
 }
-function privateVariantType(properties, result, sourceCode2) {
-  if ([...properties.values()].some((value) => value.type !== "Literal" || typeof value.value === "object" && value.value !== null || typeof value.value === "number" && !Number.isFinite(value.value))) return null;
+function privateVariantType(properties2, result, sourceCode2) {
+  if ([...properties2.values()].some((value) => value.type !== "Literal" || typeof value.value === "object" && value.value !== null || typeof value.value === "number" && !Number.isFinite(value.value))) return null;
   const fields2 = [];
   for (const [name, member3] of result.members) {
-    const value = properties.get(name);
+    const value = properties2.get(name);
     if (value === void 0) continue;
     const annotation = member3.typeAnnotation?.typeAnnotation;
     if (annotation === void 0) return null;
-    const type = name === result.tag ? sourceCode2.getText(value) : sourceCode2.getText(annotation);
+    const narrow = result.relationship.kind === "presence" ? name === result.relationship.tag : name === result.relationship.fields.left || name === result.relationship.fields.right;
+    const type = narrow ? sourceCode2.getText(value) : sourceCode2.getText(annotation);
     fields2.push(`${member3.readonly ? "readonly " : ""}${sourceCode2.getText(member3.key)}: ${type}`);
   }
   return `{ ${fields2.join("; ")} }`;
 }
 
 // src/rules/prefer-ecmascript-private-members.ts
-var NAME94 = "prefer-ecmascript-private-members";
+var NAME95 = "prefer-ecmascript-private-members";
 function isConvertible(member3) {
   return member3.accessibility === "private" && !(member3.type === "MethodDefinition" && member3.kind === "constructor") && !member3.computed && member3.key.type === "Identifier" && (member3.decorators?.length ?? 0) === 0 && !("declare" in member3 && member3.declare) && !member3.override && !(member3.type === "MethodDefinition" && (member3.value.body ?? null) === null);
 }
@@ -22208,7 +22455,7 @@ var prefer_ecmascript_private_members_default = defineRule({
     fixable: "code",
     docs: {
       description: "Prefer ECMAScript `#private` class members over TypeScript-only `private` members.",
-      url: docsUrl(NAME94)
+      url: docsUrl(NAME95)
     },
     schema: [],
     messages: {
@@ -22262,7 +22509,7 @@ var prefer_ecmascript_private_members_default = defineRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-var NAME95 = "prefer-immutable-module-constant";
+var NAME96 = "prefer-immutable-module-constant";
 var CONSTANT_NAME = /^_?[A-Z][A-Z0-9_]*$/;
 var JAVASCRIPT_FILE_RE = /\.[cm]?jsx?$/i;
 var MUTATING_METHODS = /* @__PURE__ */ new Set([
@@ -22435,7 +22682,7 @@ var prefer_immutable_module_constant_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require module-level constant collections to expose readonly state.",
-      url: docsUrl(NAME95)
+      url: docsUrl(NAME96)
     },
     schema: [],
     defaultOptions: [],
@@ -22541,7 +22788,7 @@ function unwrapTransparentExport(node) {
 }
 
 // src/rules/prefer-input-group-search.ts
-var NAME96 = "prefer-input-group-search";
+var NAME97 = "prefer-input-group-search";
 var INPUT_MODULE = /(?:^|\/)components\/ui\/input$/u;
 var INPUT_GROUP_MODULE = /(?:^|\/)components\/ui\/input-group$/u;
 var MAX_JSX_DISTANCE = 2;
@@ -22612,7 +22859,7 @@ var prefer_input_group_search_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Require search icons and shared Input controls in the same visual wrapper to use InputGroup.",
-      url: docsUrl(NAME96)
+      url: docsUrl(NAME97)
     },
     schema: [],
     messages: {
@@ -22696,7 +22943,7 @@ var prefer_input_group_search_default = defineRule({
 });
 
 // src/rules/prefer-logical-tailwind-utilities.ts
-var NAME97 = "prefer-logical-tailwind-utilities";
+var NAME98 = "prefer-logical-tailwind-utilities";
 var PREFIXES = {
   ml: "ms",
   mr: "me",
@@ -22750,7 +22997,7 @@ var prefer_logical_tailwind_utilities_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Prefer logical Tailwind utilities in explicitly opted-in bidirectional interfaces.",
-      url: docsUrl(NAME97)
+      url: docsUrl(NAME98)
     },
     schema: [
       {
@@ -22817,7 +23064,7 @@ var prefer_logical_tailwind_utilities_default = defineRule({
 });
 
 // src/rules/prefer-millisecond-control-duration-schema.ts
-var NAME98 = "prefer-millisecond-control-duration-schema";
+var NAME99 = "prefer-millisecond-control-duration-schema";
 var CONTROL_SECONDS_RE = /(?:^|_)(?:timeout|delay|interval|backoff|ttl|lease|heartbeat|debounce|throttle)_seconds$/i;
 var CONTROL_SECONDS_CAMEL_RE = /(?:timeout|delay|interval|backoff|ttl|lease|heartbeat|debounce|throttle)Seconds$/i;
 var NUMERIC_REFINEMENTS = /* @__PURE__ */ new Set(["int", "min", "max", "positive", "nonnegative", "finite", "multipleOf", "optional", "nullable", "nullish", "default", "describe", "brand", "readonly"]);
@@ -22829,7 +23076,7 @@ var prefer_millisecond_control_duration_schema_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Require application-owned Zod control-duration fields to use millisecond granularity.",
-      url: docsUrl(NAME98)
+      url: docsUrl(NAME99)
     },
     schema: [],
     messages: {
@@ -22915,7 +23162,7 @@ var prefer_millisecond_control_duration_schema_default = defineRule({
 });
 
 // src/rules/prefer-minimal-parameter-contract.ts
-var NAME99 = "prefer-minimal-parameter-contract";
+var NAME100 = "prefer-minimal-parameter-contract";
 function inlineFields(ast, node, reads) {
   const fields2 = /* @__PURE__ */ new Map();
   for (const member3 of node.members) {
@@ -22934,7 +23181,7 @@ var prefer_minimal_parameter_contract_default = defineRule({
   meta: {
     type: "suggestion",
     fixable: "code",
-    docs: { description: "Prefer the proven read-only subset for a private consumer parameter.", url: docsUrl(NAME99) },
+    docs: { description: "Prefer the proven read-only subset for a private consumer parameter.", url: docsUrl(NAME100) },
     schema: [],
     messages: {
       minimal: "This private consumer reads only {{used}} but also requires {{unused}}. Review a smaller consumer contract; preserve the original runtime object and producer type."
@@ -23333,7 +23580,7 @@ var prefer_module_level_constant_default = defineRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-var NAME100 = "prefer-module-level-schema";
+var NAME101 = "prefer-module-level-schema";
 var DEFAULT_FACTORIES = [
   "discriminatedUnion",
   "intersection",
@@ -23515,7 +23762,7 @@ var prefer_module_level_schema_default = defineRule({
     type: "problem",
     docs: {
       description: "Declare a Zod schema at module scope when it closes over nothing in the enclosing function",
-      url: docsUrl(NAME100)
+      url: docsUrl(NAME101)
     },
     schema: [
       {
@@ -23665,7 +23912,7 @@ var prefer_module_level_schema_default = defineRule({
 });
 
 // src/rules/prefer-module-level-refined-schema.ts
-var NAME101 = "prefer-module-level-refined-schema";
+var NAME102 = "prefer-module-level-refined-schema";
 var BENCHMARK_PATH_RE = /(^|[/\\])(?:benchmarks?|bench)[/\\]/;
 var FACTORIES = /* @__PURE__ */ new Set([
   "array",
@@ -23815,7 +24062,7 @@ var prefer_module_level_refined_schema_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Declare closed Zod scalar, format, and wrapper schemas at module scope.",
-      url: docsUrl(NAME101)
+      url: docsUrl(NAME102)
     },
     schema: [],
     messages: {
@@ -23913,7 +24160,7 @@ var prefer_module_level_refined_schema_default = defineRule({
 });
 
 // src/rules/prefer-multi-value-zod-literal.ts
-var NAME102 = "prefer-multi-value-zod-literal";
+var NAME103 = "prefer-multi-value-zod-literal";
 function isStaticPrimitive(node, sourceCode2) {
   node = unwrapExpression(node);
   if (node.type === "Literal") {
@@ -23940,7 +24187,7 @@ var prefer_multi_value_zod_literal_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Use the Zod 4 multi-value literal API instead of a union of literal schemas.",
-      url: docsUrl(NAME102)
+      url: docsUrl(NAME103)
     },
     schema: [
       {
@@ -24103,7 +24350,7 @@ function closedType(node) {
 }
 
 // src/rules/prefer-named-callback-domain.ts
-var NAME103 = "prefer-named-callback-domain";
+var NAME104 = "prefer-named-callback-domain";
 function isLiteralUnion(node) {
   return node.type === "TSUnionType" && node.types.length >= 2 && node.types.every((part) => part.type === "TSLiteralType");
 }
@@ -24123,7 +24370,7 @@ var prefer_named_callback_domain_default = defineRule({
     fixable: "code",
     docs: {
       description: "Name literal-union domains used by callbacks in exported contracts.",
-      url: docsUrl(NAME103)
+      url: docsUrl(NAME104)
     },
     schema: [],
     messages: {
@@ -24162,7 +24409,7 @@ var prefer_named_callback_domain_default = defineRule({
 });
 
 // src/rules/prefer-named-complex-return-type.ts
-var NAME104 = "prefer-named-complex-return-type";
+var NAME105 = "prefer-named-complex-return-type";
 function unwrap5(node) {
   if (node.type === "TSTypeReference" && node.typeArguments?.params.length === 1) {
     const [inner] = node.typeArguments.params;
@@ -24200,7 +24447,7 @@ var prefer_named_complex_return_type_default = defineRule({
     fixable: "code",
     docs: {
       description: "Prefer a named contract for structurally complex function return types.",
-      url: docsUrl(NAME104)
+      url: docsUrl(NAME105)
     },
     schema: [],
     messages: {
@@ -24223,14 +24470,14 @@ var prefer_named_complex_return_type_default = defineRule({
 });
 
 // src/rules/prefer-native-fetch-in-server-actions.ts
-var NAME105 = "prefer-native-fetch-in-server-actions";
+var NAME106 = "prefer-native-fetch-in-server-actions";
 var KY_MODULE = /^ky(?:\/.*)?$/u;
 var prefer_native_fetch_in_server_actions_default = defineRule({
   meta: {
     type: "problem",
     docs: {
       description: "Server action modules should call native fetch instead of importing ky.",
-      url: docsUrl(NAME105)
+      url: docsUrl(NAME106)
     },
     schema: [],
     defaultOptions: [],
@@ -24266,7 +24513,7 @@ function isTypeOnly(node) {
 }
 
 // src/rules/prefer-native-random-uuid.ts
-var NAME106 = "prefer-native-random-uuid";
+var NAME107 = "prefer-native-random-uuid";
 function requireUuidCallee(node) {
   return node?.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === "Literal" && node.arguments[0].value === "uuid" ? node.callee : null;
 }
@@ -24279,7 +24526,7 @@ var prefer_native_random_uuid_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
-      url: docsUrl(NAME106)
+      url: docsUrl(NAME107)
     },
     hasSuggestions: true,
     fixable: "code",
@@ -24293,11 +24540,11 @@ var prefer_native_random_uuid_default = defineRule({
     let sourceCode2;
     let directBindings = /* @__PURE__ */ new Set();
     let namespaceBindings = /* @__PURE__ */ new Set();
-    function resolve3(identifier) {
+    function resolve4(identifier) {
       return findVariable(sourceCode2.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
-      const variable = resolve3(identifier);
+      const variable = resolve4(identifier);
       if (variable !== null) destination.add(variable);
     }
     function report2(node) {
@@ -24336,7 +24583,7 @@ var prefer_native_random_uuid_default = defineRule({
         const declaration = node.parent;
         if (declaration.kind !== "const") return;
         const require2 = requireUuidCallee(node.init);
-        if (require2 === null || (resolve3(require2)?.defs.length ?? 0) > 0) return;
+        if (require2 === null || (resolve4(require2)?.defs.length ?? 0) > 0) return;
         if (node.id.type === "Identifier") {
           record(node.id, namespaceBindings);
           return;
@@ -24352,14 +24599,14 @@ var prefer_native_random_uuid_default = defineRule({
         if (node.arguments.length !== 0 || directBindings.size === 0 && namespaceBindings.size === 0) return;
         const callee = unwrapExpression(node.callee);
         if (callee.type === "Identifier") {
-          const variable2 = resolve3(callee);
+          const variable2 = resolve4(callee);
           if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
         if (callee.type !== "MemberExpression" || callee.computed || callee.object.type !== "Identifier" || callee.property.type !== "Identifier" || callee.property.name !== "v4") {
           return;
         }
-        const variable = resolve3(callee.object);
+        const variable = resolve4(callee.object);
         if (variable !== null && namespaceBindings.has(variable)) report2(node);
       }
     };
@@ -24367,7 +24614,7 @@ var prefer_native_random_uuid_default = defineRule({
 });
 
 // src/rules/prefer-node-crypto-hash.ts
-var NAME107 = "prefer-node-crypto-hash";
+var NAME108 = "prefer-node-crypto-hash";
 var UNSAFE_NAMESPACE_METHODS = /* @__PURE__ */ new Set(["__defineGetter__", "__defineSetter__", "valueOf"]);
 var UNSAFE_AUTHORITY_IDENTIFIERS = [
   "eval",
@@ -24416,13 +24663,13 @@ function readonlyNamespaceUse(receiver) {
   const parent = parentOf(use);
   return name !== null && !UNSAFE_NAMESPACE_METHODS.has(name) && parent?.type === "CallExpression" && parent.callee === use;
 }
-function readonlyLoaderUse(node, resolve3, stable2) {
+function readonlyLoaderUse(node, resolve4, stable2) {
   const receiver = outerExpression(node);
   const parent = parentOf(receiver);
   if (parent?.type === "VariableDeclarator" && parent.init === receiver) {
     if (parent.id.type === "ObjectPattern") return true;
     if (parent.id.type !== "Identifier") return false;
-    const variable = resolve3(parent.id);
+    const variable = resolve4(parent.id);
     return variable !== null && stable2(variable);
   }
   return parent?.type === "ExpressionStatement" || readonlyNamespaceUse(receiver);
@@ -24439,7 +24686,7 @@ function namespaceDefaultMayEscape(variable) {
     return (name === null || name === "default") && !readonlyNamespaceUse(outerExpression(member3));
   });
 }
-function isBuiltinLoader(node, resolve3, builtin = "crypto") {
+function isBuiltinLoader(node, resolve4, builtin = "crypto") {
   if (node.type !== "CallExpression" || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
   if (argument === void 0 || argument.type === "SpreadElement" || !isBuiltinSpecifier(argument, builtin)) {
@@ -24447,15 +24694,15 @@ function isBuiltinLoader(node, resolve3, builtin = "crypto") {
   }
   const unwrappedNodeCallee = unwrapExpression(node.callee);
   if (unwrappedNodeCallee.type === "Identifier") {
-    return unwrappedNodeCallee.name === "require" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee, resolve3);
+    return unwrappedNodeCallee.name === "require" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee, resolve4);
   }
-  return unwrappedNodeCallee.type === "MemberExpression" && unwrappedNodeCallee.object.type === "Identifier" && unwrappedNodeCallee.object.name === "process" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee.object, resolve3) && getPropertyName(unwrappedNodeCallee) === "getBuiltinModule";
+  return unwrappedNodeCallee.type === "MemberExpression" && unwrappedNodeCallee.object.type === "Identifier" && unwrappedNodeCallee.object.name === "process" && isUnshadowedBuiltinIdentifier(unwrappedNodeCallee.object, resolve4) && getPropertyName(unwrappedNodeCallee) === "getBuiltinModule";
 }
 function isBuiltinSpecifier(node, builtin) {
   return node.type === "Literal" && (node.value === builtin || node.value === `node:${builtin}`);
 }
-function isUnshadowedBuiltinIdentifier(identifier, resolve3) {
-  const variable = resolve3(identifier);
+function isUnshadowedBuiltinIdentifier(identifier, resolve4) {
+  const variable = resolve4(identifier);
   return variable === null || variable.defs.length === 0;
 }
 function propertyName2(node) {
@@ -24471,7 +24718,7 @@ var prefer_node_crypto_hash_default = defineRule({
     fixable: "code",
     docs: {
       description: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
-      url: docsUrl(NAME107)
+      url: docsUrl(NAME108)
     },
     schema: [],
     messages: { preferNodeCryptoHash: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary." }
@@ -24496,11 +24743,11 @@ var prefer_node_crypto_hash_default = defineRule({
       namespaceStability.set(variable, stable2);
       return stable2;
     }
-    function resolve3(identifier) {
+    function resolve4(identifier) {
       return findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination, shared = false) {
-      const variable = resolve3(identifier);
+      const variable = resolve4(identifier);
       if (variable === null) return;
       const stable2 = destination === namespaceBindings ? namespaceStable(variable) : stableValueBinding(variable);
       if (shared && destination === namespaceBindings && !stable2) sharedNamespaceUnsafe = true;
@@ -24520,7 +24767,7 @@ var prefer_node_crypto_hash_default = defineRule({
       if (node.source.value !== "node:crypto" || node.importKind === "type") return;
       for (const specifier of node.specifiers) {
         if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
-        const binding3 = resolve3(specifier.local);
+        const binding3 = resolve4(specifier.local);
         if (binding3 === null) continue;
         const name = importSpecifierName(specifier);
         if (name === "hash") hashBindings.set(binding3, specifier.local);
@@ -24532,7 +24779,7 @@ var prefer_node_crypto_hash_default = defineRule({
       const { sourceCode: sourceCode2 } = context;
       const constructor = unwrapExpression(create.callee);
       if (sourceCode2.getCommentsInside(node).length > 0 || constructor.type !== "Identifier" || !hasLiteralSha256HexArguments(node, update, create) || ![create, update, node].every(isPlainCall) || hashMayBeRebound()) return null;
-      const creator = resolve3(constructor);
+      const creator = resolve4(constructor);
       if (creator === null || !canonicalCreators.has(creator) || !hasOnlyDirectFactoryUses(creator) || !hasRetainedFactoryCall(creator, candidates2.map((candidate2) => candidate2.node))) return null;
       const hash = visibleHashImport(node);
       if (hash === void 0) return null;
@@ -24582,7 +24829,7 @@ var prefer_node_crypto_hash_default = defineRule({
           const shared = specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportSpecifier" && importSpecifierName(specifier) === "default";
           if (specifier.type === "ImportNamespaceSpecifier" || shared) {
             record(specifier.local, namespaceBindings, shared);
-            const variable = resolve3(specifier.local);
+            const variable = resolve4(specifier.local);
             if (!shared && variable !== null && namespaceDefaultMayEscape(variable)) sharedNamespaceUnsafe = true;
           } else if (specifier.type === "ImportSpecifier" && importSpecifierName(specifier) === "createHash") {
             record(specifier.local, directBindings);
@@ -24591,8 +24838,8 @@ var prefer_node_crypto_hash_default = defineRule({
       },
       VariableDeclarator(node) {
         if (parentOf(node).kind !== "const" || node.init === null) return;
-        const crypto = isBuiltinLoader(node.init, resolve3);
-        if (!crypto && !isBuiltinLoader(node.init, resolve3, "module")) return;
+        const crypto = isBuiltinLoader(node.init, resolve4);
+        if (!crypto && !isBuiltinLoader(node.init, resolve4, "module")) return;
         if (node.id.type === "Identifier") {
           record(node.id, crypto ? namespaceBindings : moduleBindings, crypto);
           return;
@@ -24605,16 +24852,16 @@ var prefer_node_crypto_hash_default = defineRule({
         }
       },
       CallExpression(node) {
-        if (isBuiltinLoader(node, resolve3) && !readonlyLoaderUse(node, resolve3, namespaceStable)) sharedNamespaceUnsafe = true;
+        if (isBuiltinLoader(node, resolve4) && !readonlyLoaderUse(node, resolve4, namespaceStable)) sharedNamespaceUnsafe = true;
         const callee = unwrapExpression(node.callee);
         if (callee.type === "Identifier" || callee.type === "MemberExpression" && getPropertyName(callee) === "syncBuiltinESMExports") possibleSynchronizations.push(node);
         const chain = digestChain(node);
         if (chain === null) return;
-        const provider = builtinCallProvider(chain.create, directBindings, namespaceBindings, sharedBindings, resolve3);
+        const provider = builtinCallProvider(chain.create, directBindings, namespaceBindings, sharedBindings, resolve4);
         if (provider !== null) candidates2.push({ node, ...chain, shared: provider === "shared" });
       },
       "Program:exit"() {
-        const exportsMaySynchronize = sharedNamespaceUnsafe && possibleSynchronizations.some((node) => builtinCallProvider(node, syncBindings, moduleBindings, sharedBindings, resolve3, "module") !== null);
+        const exportsMaySynchronize = sharedNamespaceUnsafe && possibleSynchronizations.some((node) => builtinCallProvider(node, syncBindings, moduleBindings, sharedBindings, resolve4, "module") !== null);
         for (const candidate2 of candidates2) {
           if (!sharedNamespaceUnsafe || !candidate2.shared && !exportsMaySynchronize) {
             const fix = existingHashFix(candidate2);
@@ -24647,19 +24894,19 @@ function isPlainCall(call) {
   const callee = unwrapExpression(call.callee);
   return !call.optional && !isPresent(call.typeArguments) && (callee.type !== "MemberExpression" || !callee.optional);
 }
-function builtinCallProvider(node, directBindings, namespaceBindings, sharedBindings, resolve3, builtin = "crypto") {
+function builtinCallProvider(node, directBindings, namespaceBindings, sharedBindings, resolve4, builtin = "crypto") {
   const unwrappedNodeCallee = unwrapExpression(node.callee);
   if (unwrappedNodeCallee.type === "Identifier") {
-    const variable2 = resolve3(unwrappedNodeCallee);
+    const variable2 = resolve4(unwrappedNodeCallee);
     if (variable2 === null || !directBindings.has(variable2)) return null;
     return sharedBindings.has(variable2) ? "shared" : "snapshot";
   }
   if (unwrappedNodeCallee.type !== "MemberExpression" || getPropertyName(unwrappedNodeCallee) !== (builtin === "crypto" ? "createHash" : "syncBuiltinESMExports")) {
     return null;
   }
-  if (isBuiltinLoader(unwrappedNodeCallee.object, resolve3, builtin)) return "shared";
+  if (isBuiltinLoader(unwrappedNodeCallee.object, resolve4, builtin)) return "shared";
   if (unwrappedNodeCallee.object.type !== "Identifier") return null;
-  const variable = resolve3(unwrappedNodeCallee.object);
+  const variable = resolve4(unwrappedNodeCallee.object);
   if (variable === null || !namespaceBindings.has(variable)) return null;
   return sharedBindings.has(variable) ? "shared" : "snapshot";
 }
@@ -24701,7 +24948,7 @@ function hasRetainedFactoryCall(binding3, removed) {
 }
 
 // src/rules/prefer-node-fs-promises.ts
-var NAME108 = "prefer-node-fs-promises";
+var NAME109 = "prefer-node-fs-promises";
 function memberName3(node) {
   if (!node.computed && node.property.type === "Identifier") return node.property.name;
   if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
@@ -24734,7 +24981,7 @@ var prefer_node_fs_promises_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Prefer promise-based Node.js filesystem APIs over synchronous calls in production modules.",
-      url: docsUrl(NAME108)
+      url: docsUrl(NAME109)
     },
     schema: [],
     messages: {
@@ -24877,7 +25124,7 @@ function sameTypeBinding(sourceCode2, alias, annotation, parameter) {
 }
 
 // src/rules/prefer-nominal-id-types.ts
-var NAME109 = "prefer-nominal-id-types";
+var NAME110 = "prefer-nominal-id-types";
 var OPERATIONAL_ROLES = /* @__PURE__ */ new Set([
   "request",
   "trace",
@@ -24993,7 +25240,7 @@ var prefer_nominal_id_types_default = defineRule({
     fixable: "code",
     docs: {
       description: "Distinguish identifier roles sharing primitive types at callable boundaries.",
-      url: docsUrl(NAME109)
+      url: docsUrl(NAME110)
     },
     schema: [],
     messages: {
@@ -25022,7 +25269,7 @@ var prefer_nominal_id_types_default = defineRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var NAME110 = "prefer-non-nullable-collection";
+var NAME111 = "prefer-non-nullable-collection";
 var ARRAY_TYPE_NAMES2 = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 var NULL_GUARD_OPERATORS = /* @__PURE__ */ new Set(["==", "==="]);
 var EMPTY_GUARD_OPERATORS = /* @__PURE__ */ new Set(["==", "===", "<="]);
@@ -25377,7 +25624,7 @@ var prefer_non_nullable_collection_default = defineRule({
     fixable: "code",
     docs: {
       description: "Suggest reviewing nullish arrays that use local empty-array defaults or a shared null-or-empty guard.",
-      url: docsUrl(NAME110)
+      url: docsUrl(NAME111)
     },
     schema: [],
     messages: {
@@ -25413,13 +25660,13 @@ var prefer_non_nullable_collection_default = defineRule({
       function checkParameter(rawParameter) {
         const parameter = rawParameter.type === "AssignmentPattern" ? rawParameter.left : rawParameter;
         if (parameter.type === "ObjectPattern") {
-          const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
-          checkDestructuredProperties(parameter, properties2);
+          const properties3 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
+          checkDestructuredProperties(parameter, properties3);
           return;
         }
         if (parameter.type !== "Identifier") return;
-        const properties = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
-        for (const property of properties) {
+        const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
+        for (const property of properties2) {
           const access = { kind: "member", object: parameter.name, property: property.name };
           record(
             property,
@@ -25427,8 +25674,8 @@ var prefer_non_nullable_collection_default = defineRule({
           );
         }
       }
-      function checkDestructuredProperties(parameter, properties) {
-        for (const property of properties) {
+      function checkDestructuredProperties(parameter, properties2) {
+        for (const property of properties2) {
           const bindingProperty = parameter.properties.find(
             (entry) => entry.type === "Property" && !entry.computed && getPropertyName(entry) === property.name
           );
@@ -25488,7 +25735,7 @@ var prefer_non_nullable_collection_default = defineRule({
 });
 
 // src/rules/prefer-nullish-filter-predicate.ts
-var NAME111 = "prefer-nullish-filter-predicate";
+var NAME112 = "prefer-nullish-filter-predicate";
 var SUMMARY = "Prefer an explicit nullish predicate when `filter(Boolean)` removes only nullish values but does not narrow the result type.";
 function isBuiltinArrayFilter(native, symbol) {
   const kinds2 = native.ast.SyntaxKind;
@@ -25545,7 +25792,7 @@ function isLiteralValue(node) {
 var prefer_nullish_filter_predicate_default = defineRule({
   meta: {
     type: "suggestion",
-    docs: { description: SUMMARY, url: docsUrl(NAME111) },
+    docs: { description: SUMMARY, url: docsUrl(NAME112) },
     hasSuggestions: true,
     fixable: "code",
     schema: [],
@@ -25590,7 +25837,7 @@ var prefer_nullish_filter_predicate_default = defineRule({
       while (findVariable(scope, `value${String(suffix)}`) !== null) suffix += 1;
       return `value${String(suffix)}`;
     }
-    function resolve3(native) {
+    function resolve4(native) {
       const { checker, file } = native;
       const symbols = file.symbolsOf(candidates2.map((candidate2) => candidate2.callee.property));
       const receivers = file.typesOf(candidates2.map((candidate2) => candidate2.callee.object));
@@ -25627,7 +25874,7 @@ var prefer_nullish_filter_predicate_default = defineRule({
       },
       "Program:exit"() {
         if (candidates2.length === 0 || tsrs === null) return;
-        const found = tsrs.run((file) => resolve3(nativeTypes(file)));
+        const found = tsrs.run((file) => resolve4(nativeTypes(file)));
         if (found === null) return;
         candidates2.forEach((candidate2, i) => {
           if (found[i] === true) report2(candidate2);
@@ -25638,7 +25885,7 @@ var prefer_nullish_filter_predicate_default = defineRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var NAME112 = "prefer-schema-for-api-payload";
+var NAME113 = "prefer-schema-for-api-payload";
 var unwrap6 = (node) => {
   let current = node ?? null;
   while (current !== null && (isErasedExpression(current) || current.type === "ChainExpression")) current = current.expression;
@@ -25921,7 +26168,7 @@ var prefer_schema_for_api_payload_default = defineRule({
     type: "problem",
     docs: {
       description: "Require Zod (or similar) schema validation on `response.json()` / `JSON.parse()` results before property access.",
-      url: docsUrl(NAME112)
+      url: docsUrl(NAME113)
     },
     schema: [],
     messages: {
@@ -26104,7 +26351,7 @@ var prefer_schema_for_api_payload_default = defineRule({
 // src/rules/prefer-semantic-colors.ts
 import { existsSync as existsSync3, lstatSync, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname3, join as join3, parse } from "path";
-var NAME113 = "prefer-semantic-colors";
+var NAME114 = "prefer-semantic-colors";
 var COLOR_PREFIXES = "text|bg|border(?:-[trblxyse])?|ring(?:-offset)?|fill|stroke|from|via|to|divide|decoration|placeholder|accent|caret|shadow|outline";
 var PALETTE = "red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|slate|gray|zinc|neutral|stone";
 var COLOR_FN = "rgba?|hsla?|hwb|oklch|oklab|lab|lch|color";
@@ -26436,7 +26683,7 @@ var prefer_semantic_colors_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Enforce semantic color tokens over raw Tailwind palette classes, arbitrary color values, and inline color literals.",
-      url: docsUrl(NAME113)
+      url: docsUrl(NAME114)
     },
     schema: [
       {
@@ -26623,7 +26870,7 @@ function packageWorkspaceGlobs(parsed) {
 }
 
 // src/rules/prefer-server-actions.ts
-var NAME114 = "prefer-server-actions";
+var NAME115 = "prefer-server-actions";
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|(?:^|\/)app(?:\/.*)?\/route\.[jt]sx?$|(?:^|\/)middleware\.[jt]sx?$|\/pages\/api\/)/;
@@ -26762,7 +27009,7 @@ var prefer_server_actions_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Prefer Next.js Server Actions over same-origin API mutations.",
-      url: docsUrl(NAME114)
+      url: docsUrl(NAME115)
     },
     schema: [
       {
@@ -26848,7 +27095,7 @@ var prefer_server_actions_default = defineRule({
 });
 
 // src/rules/prefer-server-data-preparation.ts
-var NAME115 = "prefer-server-data-preparation";
+var NAME116 = "prefer-server-data-preparation";
 var METHODS = /* @__PURE__ */ new Set(["map", "filter", "flatMap"]);
 var DOM_EVENTS = /* @__PURE__ */ new Set(["onClick", "onChange", "onInput", "onSubmit"]);
 var BINARY = /* @__PURE__ */ new Set(["===", "!==", "==", "!=", ">", ">=", "<", "<=", "+", "-", "*", "/", "%"]);
@@ -26980,7 +27227,7 @@ function typedProofs(native) {
 var prefer_server_data_preparation_default = defineRule({
   meta: {
     type: "suggestion",
-    docs: { description: "Prepare data-only input collections before an interactive client view when possible.", url: docsUrl(NAME115) },
+    docs: { description: "Prepare data-only input collections before an interactive client view when possible.", url: docsUrl(NAME116) },
     schema: [],
     messages: {
       prepareData: "Review preparing this prop-only collection in its producer or Server Component when the inputs are available there. Keep operations depending on unsaved edits or browser interaction reactive in the client."
@@ -27036,7 +27283,7 @@ var prefer_server_data_preparation_default = defineRule({
 // src/rules/prefer-shadcn-primitives.ts
 import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync3, realpathSync } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname4, isAbsolute, join as join4, parse as parsePath, relative, resolve as resolve2, sep } from "path";
+import { dirname as dirname4, isAbsolute, join as join4, parse as parsePath, relative, resolve as resolve3, sep } from "path";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -27898,7 +28145,7 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/rules/prefer-shadcn-primitives.ts
-var NAME116 = "prefer-shadcn-primitives";
+var NAME117 = "prefer-shadcn-primitives";
 var RAW_PRIMITIVES = {
   button: { capability: "Button", replacement: "Button" },
   dialog: { capability: "Dialog", replacement: "Dialog or AlertDialog family" },
@@ -28047,7 +28294,7 @@ function stringProperty(value, ...keys) {
 }
 function resolveAlias(packageRoot, alias) {
   if (isAbsolute(alias)) return null;
-  if (alias.startsWith(".")) return resolve2(packageRoot, alias);
+  if (alias.startsWith(".")) return resolve3(packageRoot, alias);
   const configPath = ["tsconfig.json", "jsconfig.json"].map((name) => join4(packageRoot, name)).find(existsSync4);
   if (configPath === void 0) return null;
   const config = readJsonc(configPath);
@@ -28061,7 +28308,7 @@ function resolveAlias(packageRoot, alias) {
   const matches = matchingAliasTargets(paths, alias);
   const [match] = matches;
   if (matches.length !== 1 || match === void 0) return null;
-  return resolve2(packageRoot, baseUrl, match);
+  return resolve3(packageRoot, baseUrl, match);
 }
 var parseModule;
 function exportsPrimitive(path, exportName) {
@@ -28200,7 +28447,7 @@ var prefer_shadcn_primitives_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Require visible raw JSX controls to use the corresponding shared shadcn primitive.",
-      url: docsUrl(NAME116)
+      url: docsUrl(NAME117)
     },
     schema: [
       {
@@ -28307,7 +28554,7 @@ function matchingAliasTargets(paths, alias) {
 }
 
 // src/rules/prefer-shared-zod-enum.ts
-var NAME117 = "prefer-shared-zod-enum";
+var NAME118 = "prefer-shared-zod-enum";
 function literalDomain(node) {
   if (node.arguments.length !== 1) return null;
   const first = node.arguments[0];
@@ -28346,7 +28593,7 @@ var prefer_shared_zod_enum_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Give repeated literal Zod enum domains one reusable module-level schema.",
-      url: docsUrl(NAME117)
+      url: docsUrl(NAME118)
     },
     schema: [],
     messages: {
@@ -28403,7 +28650,7 @@ var prefer_shared_zod_enum_default = defineRule({
 });
 
 // src/rules/prefer-switch-for-repeated-equality.ts
-var NAME118 = "prefer-switch-for-repeated-equality";
+var NAME119 = "prefer-switch-for-repeated-equality";
 function discriminantName(test) {
   if (test.type !== "BinaryExpression" || test.operator !== "===") return null;
   const leftIsCase = isCaseValue(test.left);
@@ -28480,7 +28727,7 @@ var prefer_switch_for_repeated_equality_default = defineRule({
     fixable: "code",
     docs: {
       description: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
-      url: docsUrl(NAME118)
+      url: docsUrl(NAME119)
     },
     schema: [],
     messages: {
@@ -28530,8 +28777,8 @@ var prefer_switch_for_repeated_equality_default = defineRule({
 });
 
 // src/rules/prefer-test-fixture-reuse.ts
-var NAME119 = "prefer-test-fixture-reuse";
-var MAX_DEPTH = 8;
+var NAME120 = "prefer-test-fixture-reuse";
+var MAX_DEPTH2 = 8;
 var FRAMEWORKS = /* @__PURE__ */ new Set(["vitest", "@playwright/test"]);
 var TEST_MODIFIERS4 = /* @__PURE__ */ new Set(["only", "skip", "concurrent", "sequential"]);
 function stableBinding(source, identifier) {
@@ -28549,7 +28796,7 @@ function valueImport(definition) {
 }
 function constructorBinding(source, node, depth = 0) {
   node = unwrapExpression(node);
-  if (node.type !== "Identifier" || depth >= MAX_DEPTH) return null;
+  if (node.type !== "Identifier" || depth >= MAX_DEPTH2) return null;
   const variable = stableBinding(source, node);
   const definition = variable?.defs[0];
   if (variable === null || definition === void 0) return null;
@@ -28559,7 +28806,7 @@ function constructorBinding(source, node, depth = 0) {
 }
 function fixtureApi(source, expression, depth = 0) {
   const node = unwrapExpression(expression);
-  if (node.type !== "Identifier" || depth >= MAX_DEPTH) return null;
+  if (node.type !== "Identifier" || depth >= MAX_DEPTH2) return null;
   const variable = stableBinding(source, node);
   const definition = variable?.defs[0];
   if (variable === null || definition === void 0) return null;
@@ -28659,7 +28906,7 @@ var prefer_test_fixture_reuse_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Reuse a requested test fixture instead of constructing another instance of its class.",
-      url: docsUrl(NAME119)
+      url: docsUrl(NAME120)
     },
     schema: [],
     messages: { reuseFixture: "This class is already supplied by the requested `{{fixture}}` fixture; reuse it or request a typed factory for independent instances." }
@@ -28693,7 +28940,7 @@ var prefer_test_fixture_reuse_default = defineRule({
 });
 
 // src/rules/prefer-typed-reflection.ts
-var NAME120 = "prefer-typed-reflection";
+var NAME121 = "prefer-typed-reflection";
 function knownType(native, type) {
   if (type.isUnionType()) return type.getTypes().every((part) => knownType(native, part));
   const flags = native.sync.TypeFlags;
@@ -28723,7 +28970,7 @@ var prefer_typed_reflection_default = defineRule({
     fixable: "code",
     docs: {
       description: "Prefer typed access when Reflect.get or Reflect.apply discards a known contract.",
-      url: docsUrl(NAME120)
+      url: docsUrl(NAME121)
     },
     schema: [],
     messages: {
@@ -28889,7 +29136,7 @@ var prefer_typed_reflection_default = defineRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var NAME121 = "prefer-whole-object-assertion";
+var NAME122 = "prefer-whole-object-assertion";
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"]
@@ -28979,7 +29226,7 @@ var prefer_whole_object_assertion_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Collapse consecutive assertions on one object into a whole-object assertion so related mismatches are reported together.",
-      url: docsUrl(NAME121)
+      url: docsUrl(NAME122)
     },
     messages: {
       combineAssertions: "Consider combining these {{count}} assertions on `{{receiver}}` with `toMatchObject` when structural matching preserves property presence and getter or proxy behavior.",
@@ -29126,7 +29373,7 @@ var prefer_whole_object_assertion_default = defineRule({
 });
 
 // src/rules/prefer-zod-enum-validator.ts
-var NAME122 = "prefer-zod-enum-validator";
+var NAME123 = "prefer-zod-enum-validator";
 function isInput(node, name) {
   if (node == null) return false;
   const value = unwrapExpression(node);
@@ -29217,7 +29464,7 @@ var prefer_zod_enum_validator_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Express closed string validators with a reusable Zod enum schema.",
-      url: docsUrl(NAME122)
+      url: docsUrl(NAME123)
     },
     schema: [],
     messages: { useEnumSchema: "Replace this closed string validator with a named z.enum([\u2026]) schema and derive its type with z.infer. Use parse for parsing or safeParse for a boolean check; preserve intentional failure behavior." }
@@ -29245,7 +29492,7 @@ var prefer_zod_enum_validator_default = defineRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var NAME123 = "prefer-zod-infer";
+var NAME124 = "prefer-zod-infer";
 function absent(value) {
   return value === void 0 || value === null;
 }
@@ -29621,7 +29868,7 @@ var prefer_zod_infer_default = defineRule({
     fixable: "code",
     docs: {
       description: "Derive a type from its Zod schema with `z.infer` instead of hand-writing a twin declaration beside it.",
-      url: docsUrl(NAME123)
+      url: docsUrl(NAME124)
     },
     schema: [
       {
@@ -30071,7 +30318,7 @@ function returnsContract(authority, returned2) {
 }
 
 // src/rules/prefer-zod-parse-output-type.ts
-var NAME124 = "prefer-zod-parse-output-type";
+var NAME125 = "prefer-zod-parse-output-type";
 function isLocalZodObjectSchema(node, namespaces) {
   let current = node;
   while (current.type === "CallExpression") {
@@ -30217,7 +30464,7 @@ var prefer_zod_parse_output_type_default = defineRule({
     fixable: "code",
     docs: {
       description: "Consider deriving validated return contracts from the Zod schema when the schema owns the contract.",
-      url: docsUrl(NAME124)
+      url: docsUrl(NAME125)
     },
     schema: [],
     messages: {
@@ -30505,7 +30752,7 @@ var production_derived_test_cases_default = defineRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-var NAME125 = "repeated-static-call-cases";
+var NAME126 = "repeated-static-call-cases";
 var TEST_MODULES2 = /* @__PURE__ */ new Set(["@jest/globals", "@playwright/test", "bun:test", "node:test", "vitest"]);
 var TEST_NAMES3 = /* @__PURE__ */ new Set(["it", "test"]);
 var TEST_MODIFIERS5 = /* @__PURE__ */ new Set(["concurrent", "fails", "only", "sequential", "skip"]);
@@ -30629,7 +30876,7 @@ var repeated_static_call_cases_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Review three or more consecutive static-input call assertions as potential named cases.",
-      url: docsUrl(NAME125)
+      url: docsUrl(NAME126)
     },
     schema: [],
     messages: { repeatedStaticCallCases: "These {{count}} consecutive assertions repeat a call with static inputs. If independent, use named parameterized cases or subtests; preserve ordered scenarios as one test." }
@@ -30771,7 +31018,7 @@ function isPrimitiveReturn(node, annotation) {
 }
 
 // src/rules/require-assert-never.ts
-var NAME126 = "require-assert-never";
+var NAME127 = "require-assert-never";
 function isRuntimeHandlingStatement(statement) {
   if (statement.type === "EmptyStatement") return false;
   if (statement.type === "BreakStatement") return statement.label !== null;
@@ -30831,7 +31078,7 @@ var require_assert_never_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
-      url: docsUrl(NAME126)
+      url: docsUrl(NAME127)
     },
     schema: [],
     messages: {
@@ -30875,7 +31122,7 @@ var require_assert_never_default = defineRule({
 });
 
 // src/rules/require-button-accessible-name.ts
-var NAME127 = "require-button-accessible-name";
+var NAME128 = "require-button-accessible-name";
 var DELEGATING_PROPS = /* @__PURE__ */ new Set(["render", "asChild"]);
 function delegatesRendering(opening) {
   return opening.attributes.some(
@@ -30888,7 +31135,7 @@ var require_button_accessible_name_default = defineRule({
     type: "problem",
     docs: {
       description: "Require an accessible name on statically unnamed native or configured JSX buttons.",
-      url: docsUrl(NAME127)
+      url: docsUrl(NAME128)
     },
     schema: [
       {
@@ -30942,7 +31189,7 @@ var require_button_accessible_name_default = defineRule({
 });
 
 // src/rules/require-camelcase-properties.ts
-var NAME128 = "require-camelcase-properties";
+var NAME129 = "require-camelcase-properties";
 var SNAKE_CASE_RE2 = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/u;
 function blocksRename(member3, name) {
   if (member3.type === "TSIndexSignature" || "computed" in member3 && member3.computed) return true;
@@ -30956,7 +31203,7 @@ var require_camelcase_properties_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require unquoted lower snake_case TypeScript properties and dot access to use camelCase.",
-      url: docsUrl(NAME128)
+      url: docsUrl(NAME129)
     },
     schema: [],
     defaultOptions: [],
@@ -31020,7 +31267,7 @@ var require_camelcase_properties_default = defineRule({
 });
 
 // src/rules/require-constrained-schema-integer.ts
-var NAME129 = "require-constrained-schema-integer";
+var NAME130 = "require-constrained-schema-integer";
 var FIELD_MINIMUMS = /* @__PURE__ */ new Map([["limit", 1], ["version", 0]]);
 var NUMBER_FACTORIES = /* @__PURE__ */ new Set(["number", "int", "int32", "uint32"]);
 var OBJECT_FACTORIES = /* @__PURE__ */ new Set(["object", "strictObject", "looseObject"]);
@@ -31062,7 +31309,7 @@ var require_constrained_schema_integer_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Declare integer and lower-bound validation for numeric limit and version schema fields.",
-      url: docsUrl(NAME129)
+      url: docsUrl(NAME130)
     },
     schema: [],
     messages: { constrainInteger: "Declare `{{field}}` as an integer with a lower bound of {{minimum}} or greater, or reuse its named domain schema." }
@@ -31541,14 +31788,14 @@ function closedNominalInheritanceFix(sourceCode2, file, call, consumer, implemen
 }
 
 // src/rules/require-explicit-contract-implementation.ts
-var NAME130 = "require-explicit-contract-implementation";
+var NAME131 = "require-explicit-contract-implementation";
 var require_explicit_contract_implementation_default = defineRule({
   meta: {
     type: "problem",
     fixable: "code",
     docs: {
       description: "Require nominal inheritance when an injected abstract class is rejected by an instanceof guard.",
-      url: docsUrl(NAME130)
+      url: docsUrl(NAME131)
     },
     schema: [],
     messages: {
@@ -32239,7 +32486,7 @@ function abstractContractOperations(node, functionAliases) {
 }
 
 // src/rules/require-explicit-service-contract.ts
-var NAME131 = "require-explicit-service-contract";
+var NAME132 = "require-explicit-service-contract";
 var JAVASCRIPT_FILE_RE2 = /\.(?:js|jsx|mjs|cjs)$/iu;
 var BOUNDARY_SUFFIX = /(?:Service|ServiceImpl|Store|Repository|Provider|Executor|Enqueuer|Runner|Platform|Manager|ManagerImpl|Detector|Control|Refresher|Reader|Settlement|Retry|Stop|Catalog|DAO)$/u;
 var NON_SERVICE_SUFFIX = /(?:Router|Middleware|Builder)$/u;
@@ -32255,7 +32502,7 @@ var require_explicit_service_contract_default = defineRule({
     type: "problem",
     docs: {
       description: "Require explicit contracts for classes that invoke retained collaborators.",
-      url: docsUrl(NAME131)
+      url: docsUrl(NAME132)
     },
     schema: [],
     fixable: "code",
@@ -32291,7 +32538,7 @@ var require_explicit_service_contract_default = defineRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var NAME132 = "require-fetch-timeout";
+var NAME133 = "require-fetch-timeout";
 function emptySignal(expression, resolvesToGlobal) {
   const value = unwrapExpression(expression);
   if (value.type === "Literal" && value.value === null)
@@ -32353,7 +32600,7 @@ var require_fetch_timeout_default = defineRule({
     type: "problem",
     docs: {
       description: "Require an explicit abort signal on locally analyzable global fetch calls.",
-      url: docsUrl(NAME132)
+      url: docsUrl(NAME133)
     },
     schema: [
       {
@@ -32445,7 +32692,7 @@ var require_fetch_timeout_default = defineRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-var NAME133 = "require-interface-for-exported-class";
+var NAME134 = "require-interface-for-exported-class";
 var JAVASCRIPT_FILE_RE3 = /\.(?:js|jsx|mjs|cjs)$/iu;
 function isPublicInstanceMember2(member3) {
   return !member3.static && member3.accessibility !== "private" && member3.accessibility !== "protected" && member3.key.type !== "PrivateIdentifier";
@@ -32506,7 +32753,7 @@ var require_interface_for_exported_class_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Require exported concrete classes with public behavior to declare a contract.",
-      url: docsUrl(NAME133)
+      url: docsUrl(NAME134)
     },
     schema: [],
     fixable: "code",
@@ -32548,7 +32795,7 @@ var require_interface_for_exported_class_default = defineRule({
 });
 
 // src/rules/require-jwt-lifetime.ts
-var NAME134 = "require-jwt-lifetime";
+var NAME135 = "require-jwt-lifetime";
 function isJoseValueImport(declaration) {
   return declaration.type === "ImportDeclaration" && declaration.importKind !== "type" && declaration.source.value === "jose";
 }
@@ -32557,7 +32804,7 @@ var require_jwt_lifetime_default = defineRule({
     type: "problem",
     docs: {
       description: "Require an expiration claim or a maximum token age when returning a verified JWT.",
-      url: docsUrl(NAME134)
+      url: docsUrl(NAME135)
     },
     schema: [],
     messages: { lifetime: "Require the JWT exp claim or set maxTokenAge before returning this verification result." }
@@ -32616,7 +32863,7 @@ var require_jwt_lifetime_default = defineRule({
 });
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var NAME135 = "require-pascal-case-zod-schema-name";
+var NAME136 = "require-pascal-case-zod-schema-name";
 var PASCAL_SCHEMA_NAME_RE = /^[A-Z][A-Za-z0-9]*Schema$/;
 var BENCHMARK_PATH_RE2 = /(^|[\\/])(?:benchmarks?|bench)[\\/]/;
 var NON_SCHEMA_TERMINALS2 = /* @__PURE__ */ new Set([
@@ -32787,7 +33034,7 @@ var require_pascal_case_zod_schema_name_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
-      url: docsUrl(NAME135)
+      url: docsUrl(NAME136)
     },
     schema: [],
     defaultOptions: [],
@@ -32897,7 +33144,7 @@ var require_pascal_case_zod_schema_name_default = defineRule({
 });
 
 // src/rules/require-port-for-service.ts
-var NAME136 = "require-port-for-service";
+var NAME137 = "require-port-for-service";
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
 var TRANSPORT_WRAPPER_NAME_RE = /(?:Client$|^Http[A-Z])/;
 var ERROR_VALUE_NAME_RE = /Error$/;
@@ -33031,7 +33278,7 @@ var require_port_for_service_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Advise when an exported service with injected collaborators has public methods not covered by its declared ports.",
-      url: docsUrl(NAME136)
+      url: docsUrl(NAME137)
     },
     schema: [],
     fixable: "code",
@@ -33071,7 +33318,7 @@ var require_port_for_service_default = defineRule({
 });
 
 // src/rules/require-sql-access-class.ts
-var NAME137 = "require-sql-access-class";
+var NAME138 = "require-sql-access-class";
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -33269,7 +33516,7 @@ var require_sql_access_class_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Keep SQL reads and writes inside a class that receives its database dependency.",
-      url: docsUrl(NAME137)
+      url: docsUrl(NAME138)
     },
     schema: [],
     messages: {
@@ -33341,7 +33588,7 @@ function staticMatcherFix(sourceCode2, property) {
 }
 
 // src/rules/require-static-next-matcher.ts
-var NAME138 = "require-static-next-matcher";
+var NAME139 = "require-static-next-matcher";
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function isStaticValue(node) {
   const value = unwrapExpression(node);
@@ -33373,7 +33620,7 @@ var require_static_next_matcher_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require Next.js middleware and proxy matcher configuration to contain only build-time literals.",
-      url: docsUrl(NAME138)
+      url: docsUrl(NAME139)
     },
     schema: [],
     messages: {
@@ -33417,7 +33664,7 @@ var require_static_next_matcher_default = defineRule({
 });
 
 // src/rules/require-svg-accessible-name.ts
-var NAME139 = "require-svg-accessible-name";
+var NAME140 = "require-svg-accessible-name";
 var DECORATIVE_ROLES = /* @__PURE__ */ new Set(["none", "presentation"]);
 var NAME_ATTRIBUTES = ["aria-label", "aria-labelledby"];
 var NO_ICON_MODULES = [];
@@ -33426,7 +33673,7 @@ var require_svg_accessible_name_default = defineRule({
     type: "problem",
     docs: {
       description: "Require a name or explicit decorative semantics on inline SVG elements.",
-      url: docsUrl(NAME139)
+      url: docsUrl(NAME140)
     },
     schema: [],
     messages: {
@@ -33458,7 +33705,7 @@ var require_svg_accessible_name_default = defineRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var NAME140 = "require-use-form-default-values";
+var NAME141 = "require-use-form-default-values";
 var UNSAFE_FORM_MEMBERS = /* @__PURE__ */ new Set(["__defineGetter__", "__defineSetter__", "__proto__", "valueOf"]);
 function staticPropertyName2(property) {
   return property.computed ? null : getPropertyName(property);
@@ -33501,7 +33748,7 @@ var require_use_form_default_values_default = defineRule({
     type: "problem",
     docs: {
       description: "Require explicit form-level initialization or a field default for directly bound Controller fields.",
-      url: docsUrl(NAME140)
+      url: docsUrl(NAME141)
     },
     schema: [],
     messages: { requireUseFormDefaultValues: "Add non-undefined defaultValues/values to the associated useForm call or non-undefined defaultValue to this field." }
@@ -33640,7 +33887,7 @@ var require_use_form_default_values_default = defineRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var NAME141 = "require-use-server-in-actions-file";
+var NAME142 = "require-use-server-in-actions-file";
 var ACTION_MODULE_RE = /(?:^|\/)app\/.*\/(?:actions|[^/]+-actions)\.[cm]?[jt]s$/u;
 function isUseServerDirective2(statement) {
   return statement.type === "ExpressionStatement" && statement.directive === "use server";
@@ -33661,7 +33908,7 @@ var require_use_server_in_actions_file_default = defineRule({
     type: "problem",
     docs: {
       description: "route action module missing the use server directive",
-      url: docsUrl(NAME141)
+      url: docsUrl(NAME142)
     },
     schema: [],
     messages: {
@@ -33687,7 +33934,7 @@ var require_use_server_in_actions_file_default = defineRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var NAME142 = "require-zod-form-validation";
+var NAME143 = "require-zod-form-validation";
 var ZOD_PARSE_METHODS = /* @__PURE__ */ new Set([
   "parse",
   "safeParse",
@@ -33746,7 +33993,7 @@ var require_zod_form_validation_default = defineRule({
     type: "problem",
     docs: {
       description: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
-      url: docsUrl(NAME142)
+      url: docsUrl(NAME143)
     },
     schema: [],
     messages: {
@@ -34034,7 +34281,7 @@ function declaresFramework(metadata, name) {
 }
 
 // src/rules/sole-export-matches-filename.ts
-var NAME143 = "sole-export-matches-filename";
+var NAME144 = "sole-export-matches-filename";
 var EXCLUDED_STEMS = /* @__PURE__ */ new Set(["global", "index", "types"]);
 function stem3(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
@@ -34048,7 +34295,7 @@ var sole_export_matches_filename_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Make a module filename reflect its sole named public runtime export.",
-      url: docsUrl(NAME143)
+      url: docsUrl(NAME144)
     },
     schema: [],
     messages: {
@@ -34791,7 +35038,7 @@ var stepdown_default = defineRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var NAME144 = "store-insert-requires-on-conflict";
+var NAME145 = "store-insert-requires-on-conflict";
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
 var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b|\bINSERT\b[\s\S]*?\bSELECT\b[\s\S]*?\bWHERE\s+NOT\s+EXISTS\b/i;
 var REPLAY_CONTRACT_NAME = /(?:enqueue|ensure|migrate|recordOnce|schedule|seed|upsert|getOrCreate|createIfAbsent|insertIfAbsent)/i;
@@ -34820,7 +35067,7 @@ var store_insert_requires_on_conflict_default = defineRule({
     type: "problem",
     docs: {
       description: "Review conflict handling for embedded inserts in replay-named callables.",
-      url: docsUrl(NAME144)
+      url: docsUrl(NAME145)
     },
     schema: [],
     messages: {
@@ -34845,7 +35092,7 @@ var store_insert_requires_on_conflict_default = defineRule({
 });
 
 // src/rules/test-loops-over-literal-cases.ts
-var NAME145 = "test-loops-over-literal-cases";
+var NAME146 = "test-loops-over-literal-cases";
 var TEST_CALLERS3 = /* @__PURE__ */ new Set(["it", "test"]);
 var TEST_MODIFIERS6 = /* @__PURE__ */ new Set(["concurrent", "fails", "only", "sequential", "skip"]);
 var ASSERTION_ROOTS = /* @__PURE__ */ new Set([
@@ -34941,7 +35188,7 @@ var test_loops_over_literal_cases_default = defineRule({
     type: "suggestion",
     docs: {
       description: "Disallow assertions over an inline literal case loop in a test; parameterization reports and names every case independently.",
-      url: docsUrl(NAME145)
+      url: docsUrl(NAME146)
     },
     schema: [],
     messages: {
@@ -35005,7 +35252,7 @@ var test_loops_over_literal_cases_default = defineRule({
 });
 
 // src/rules/test-phase-label-comment.ts
-var NAME146 = "test-phase-label-comment";
+var NAME147 = "test-phase-label-comment";
 var PHASE_WORD = String.raw`arrange|act|assert(?:ion)?s?|given|when|then|exercise|execute|verif(?:y|ication)|cleanup|prepare|sanity(?:\s+check)?`;
 var PHASE_RE = new RegExp(
   String.raw`^[-=~*_#.\s]{0,40}(?:${PHASE_WORD})(?:\s*(?:[/&+,|]|->|and)\s*(?:${PHASE_WORD}))*[-=~*_#.\s:;!–—]{0,40}$`,
@@ -35033,7 +35280,7 @@ var test_phase_label_comment_default = defineRule({
     fixable: "code",
     docs: {
       description: "Tests must not use bare Arrange, Act, Assert, Given, When, or Then phase comments.",
-      url: docsUrl(NAME146)
+      url: docsUrl(NAME147)
     },
     schema: [],
     messages: { removeLabel: "Bare test phase label \u2014 delete it and let the test names and helpers carry the structure." }
@@ -35174,6 +35421,7 @@ var RULES = {
   "no-zod-native-enum": no_zod_native_enum_default,
   "no-zod-parse-typed-object": no_zod_parse_typed_object_default,
   "prefer-await-in-async-return": prefer_await_in_async_return_default,
+  "prefer-coded-error-result": prefer_coded_error_result_default,
   "prefer-constant-time-secret-compare": prefer_constant_time_secret_compare_default,
   "prefer-dependency-interface": prefer_dependency_interface_default,
   "prefer-discriminated-union": prefer_discriminated_union_default,