@sarj/eslint-plugin 19.17.0 → 19.19.0

package/dist/catalog.js

@@ -2,7 +2,7 @@ import {
   publicDocumentation,
   ruleSpec,
   src_default
-} from "./chunk-4USNCXB3.js";
+} from "./chunk-UI4ADSAA.js";
 
 // src/docs/directive-disable-enable-pair.ts
 var DIRECTIVE_DISABLE_ENABLE_PAIR_DOCUMENTATION = {
@@ -5118,11 +5118,13 @@ var PREFER_DISCRIMINATED_UNION_DOCUMENTATION = {
   summary: "Preserve producer-proven tag/payload and Boolean state relationships in return types.",
   defaultLevel: "warning",
   rationale: "A flat object with optional branch data loses the relationship between a tag and its payload. Callers cannot narrow to the required fields, and the type permits incomplete or contradictory combinations.",
-  remediation: "If the variants are mutually exclusive, represent each with a literal tag and its required payload. Preserve shared fields on every member, including payload value types and nullability. For a producer returning a subset of a broader wire contract, give the producer a precise domain return type after validation.",
+  remediation: "If the variants are mutually exclusive, represent each with a literal tag and its required payload. For predicates over one current state, consider returning that authoritative state instead of storing multiple derived flags. Preserve every valid state, independent dimension, shared field, payload value type and nullability. For a producer returning a subset of a broader wire contract, give the producer a precise domain return type after validation.",
   category: "correctness",
   autofix: "safe",
   limitations: [
-    "Names, Boolean counts and optional-field counts never establish a finding. A producer's literal writes establish either tag-specific payload presence or a pair of required Boolean fields with two or three distinct combinations, with both fields varying. Boolean members may use boolean, true | false or one unmerged nongeneric local alias of either. All four combinations, constant dimensions, optional/unknown dimensions and expression-valued flags are excluded. At most eight Boolean fields are compared. Only one relationship is reported per contract; payload evidence takes precedence. Independently nullable payloads do not erase Boolean evidence.",
+    "Names, Boolean counts and optional-field counts never establish a finding. A producer's literal writes establish either tag-specific payload presence or a pair of required Boolean fields with two or three distinct combinations, with both fields varying. Boolean members may use boolean, true | false or one unmerged nongeneric local alias of either. All four combinations, constant dimensions and optional/unknown dimensions are excluded. Expression-valued flags require the separate typed evidence described below. At most eight Boolean fields are compared. Only one relationship is reported per contract; existing literal/payload evidence takes precedence. Independently nullable payloads do not erase Boolean evidence.",
+    "With type services enabled, a synchronous nongeneric producer with exactly one own return, a final direct object return and a supported flat local contract also exposes strict equality predicates over the same earlier local const binding. Native types at both reads must be finite domains of at most sixteen string/number literals containing both distinct singleton comparison values. Literal constants and direct named-import/local enum members are supported; enum declarations and members are resolved by symbol identity and raw runtime literal values, including renamed imports and reexports. At most 128 candidate pairs per file are analyzed; exceeding the bound abstains from all typed findings in that file. No automatic fix is offered for these projections.",
+    "The const snapshot may be destructured or copied from another primitive binding, passed to callbacks, or read by closures without losing its value. Mutable bindings, parameters and module captures, property reads/getters, open/nullable/object/symbol domains, async producers, multiple own returns, generic/inherited/imported contracts and dynamic eval abstain. Nested callback returns do not belong to the producer. Enum namespace writes, aliases, escapes, computed accesses, calls and merged declarations in the analyzed file abstain. Cross-file enum declarations can supply type/constant identity; external mutation, dishonest declarations/assertions and runtime monkeypatching are not modeled. The analysis proves a relationship under those type and mutation assumptions, not domain intent or a whole-program ownership guarantee.",
     "Producer analysis requires a finite literal tag, every declared tag syntactically witnessed, exhaustive simple return paths without literal constant conditions, plain object returns, and consistent optional-field presence for each tag. It resolves only unmerged local aliases/interfaces without inheritance or generics, one local alias of a literal tag domain, and the built-in Promise around async returns. Callable or opaque own then properties abstain for async producers because Promise assimilation can replace the fulfilled value. Inherited then methods and external prototype mutation are not modeled. This is syntax-only evidence of field presence; explicit undefined, void and null payloads do not establish payload requirements, while expression value types are not inferred. Type-only assertion/satisfies/non-null wrappers, literal computed string keys and a sole-use const immediately before its return are recognized. Const alias chains, observation, mutation and dynamic eval abstain. Dynamic returns, spreads, dynamic computed keys, accessors, loops and try statements are deliberately skipped.",
     "A switch producer is supported only for a non-overloaded function declaration when its sole body statement switches on an unchanged direct string or number parameter, has unique same-kind literal labels and a default, and every nonempty case body is a sole object return or throw, optionally inside sole blocks. Empty labels may share the next terminating body; nested conditions, conditional returns, statement prefixes, breaks, other fallthrough, captured/closed inputs, dynamic eval and switches under preceding control flow abstain. Broad parameter domains establish input witnesses for each label and the default; this does not infer branch-specific runtime effects or expression value types. Path visits, depth and returned objects are bounded conservatively.",
     "These are refactoring advisories, not proven defects or proof that other writers cannot produce more states. Historical observations, partial results, unknown states and independently completing operations may need the broader contract. Review all readers and writers before migrating a shared contract; preserve every valid combination. A union of existing literal flag pairs is the smallest type-only replacement; a named disposition is a reviewed domain migration.",
@@ -5138,6 +5140,8 @@ var PREFER_DISCRIMINATED_UNION_DOCUMENTATION = {
     { id: "explicit-produced-variants", scenarioId: "produced-variants", title: "Give each produced variant its payload", outcome: "no-match", files: [{ path: "src/job.ts", source: 'function job(done: boolean): { phase: "queued"; ticket: string } | { phase: "complete" } { return done ? { phase: "complete" } : { phase: "queued", ticket: "t" }; }' }], focusPath: "src/job.ts", expectedCount: 0, public: true },
     { id: "flat-switch-producer", scenarioId: "switch-producer", title: "A complete dispatcher preserves each returned variant", outcome: "match", files: [{ path: "src/job.ts", source: 'function job(command: string): { phase: "queued" | "complete"; ticket?: string } { switch (command) { case "start": return { phase: "queued", ticket: "t" }; default: return { phase: "complete" }; } }' }], focusPath: "src/job.ts", expectedCount: 1, public: true },
     { id: "explicit-switch-variants", scenarioId: "switch-producer", title: "An explicit dispatcher result supports payload narrowing", outcome: "no-match", files: [{ path: "src/job.ts", source: 'function job(command: string): { phase: "queued"; ticket: string } | { phase: "complete" } { switch (command) { case "start": return { phase: "queued", ticket: "t" }; default: return { phase: "complete" }; } }' }], focusPath: "src/job.ts", expectedCount: 0, public: true },
+    { id: "immutable-state-projections", scenarioId: "state-projection", title: "Two predicates over one immutable phase cannot both be true", outcome: "match", files: [{ path: "src/projection.ts", source: 'type Phase = "ready" | "waiting" | "unknown"; declare function snapshot(): Phase; function state(): { ready: boolean; waiting: boolean } { const phase = snapshot(); return { ready: phase === "ready", waiting: phase === "waiting" }; }' }], focusPath: "src/projection.ts", expectedCount: 1, public: true },
+    { id: "authoritative-state", scenarioId: "state-projection", title: "Return the phase while preserving the independent timeout dimension", outcome: "no-match", files: [{ path: "src/projection.ts", source: 'type Phase = "ready" | "waiting" | "reconnecting" | "unknown"; declare function snapshot(): Phase; function state(timeout: boolean): { phase: Phase; timeout: boolean } { const phase = snapshot(); return { phase, timeout }; }' }], focusPath: "src/projection.ts", expectedCount: 0, public: true },
     {
       id: "safe-autofix",
       title: "Preserve an unused private producer's exact existing variants",
@@ -6437,6 +6441,57 @@ var PRODUCTION_DERIVED_TEST_CASES_DOCUMENTATION = {
   ]
 };
 
+// src/docs/react-prefer-updater-function.ts
+var CART = "import { useState } from 'react'; export function Cart({ load }: { load: () => Promise<string> }) { const [items, setItems] = useState<string[]>([]); const add = async () => { const item = await load(); ";
+var CART_END = ' }; return <button type="button" onClick={add}>{items.length}</button>; }';
+var RENDER_PHASE = "import { useState } from 'react'; export function Panel({ request }: { request: boolean }) { const [dialog, setDialog] = useState({ open: request, request }); if (dialog.request !== request) { setDialog({ open: request || dialog.open, request }); } return <p>{String(dialog.open)}</p>; }";
+var REACT_PREFER_UPDATER_FUNCTION_DOCUMENTATION = {
+  defaultLevel: "warning",
+  summary: "Use the updater form when the next React state is built from the current state.",
+  rationale: "A state variable holds the snapshot from the render that created the callback. After an await, in a timer, promise callback, subscription or effect, or when two updates run before React re-renders, that snapshot is stale. `setItems([...items, item])` then drops whatever another update added in the meantime. An updater receives the latest queued state, so each update builds on the one before it.",
+  remediation: "Pass an updater instead. Rewrite `setItems([...items, item])` as `setItems((previous) => [...previous, item])`, and read `previous` wherever the argument read the state or a local derived from it. Compute IDs, timestamps and other impure values before the call, because React runs updaters twice in Strict Mode development builds.",
+  category: "correctness",
+  limitations: [
+    "The rule is advisory and has no automatic fix. In a synchronous event handler that updates once, the snapshot is still current, so the rewrite keeps today's behavior and protects the handler against a later await or a second update.",
+    "The rule pairs a setter with its state through one array destructure of a React useState call, including renamed, default and namespace React imports, and resolves every read by scope. It ignores setters reached through props, aliases or custom hooks that return state tuples. It also ignores object-destructured state, useReducer dispatch and reassigned bindings.",
+    "The rule reports only state reads that the setter argument itself evaluates. It ignores reads inside nested functions, type-only reads, a bare identity write and next values first stored in a local. It also ignores setter calls made directly in the function that declares the state, because they run during render, where the state belongs to the render in progress."
+  ],
+  references: [
+    "https://react.dev/reference/react/useState#updating-state-based-on-the-previous-state",
+    "https://react.dev/learn/queueing-a-series-of-state-updates",
+    "https://bun.com/docs/lint/rules/bun/react-prefer-updater-function"
+  ],
+  examples: [
+    {
+      id: "snapshot-after-await",
+      title: "Append to the render snapshot after an await",
+      outcome: "match",
+      files: [{ path: "src/cart.tsx", source: `${CART}setItems([...items, item]);${CART_END}` }],
+      focusPath: "src/cart.tsx",
+      expectedCount: 1,
+      public: true
+    },
+    {
+      id: "updater-after-await",
+      title: "Append to the latest state through an updater",
+      outcome: "no-match",
+      files: [{ path: "src/cart.tsx", source: `${CART}setItems((previous) => [...previous, item]);${CART_END}` }],
+      focusPath: "src/cart.tsx",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "render-phase-update",
+      title: "Adjust state from the render in progress",
+      outcome: "no-match",
+      files: [{ path: "src/panel.tsx", source: RENDER_PHASE }],
+      focusPath: "src/panel.tsx",
+      expectedCount: 0,
+      public: false
+    }
+  ]
+};
+
 // src/docs/repeated-static-call-cases.ts
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Review three or more consecutive static-input call assertions as potential named cases.",
@@ -7574,6 +7629,7 @@ var RULE_DOCUMENTATION = {
   "prefer-zod-infer": PREFER_ZOD_INFER_DOCUMENTATION,
   "prefer-zod-parse-output-type": PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION,
   "production-derived-test-cases": PRODUCTION_DERIVED_TEST_CASES_DOCUMENTATION,
+  "react-prefer-updater-function": REACT_PREFER_UPDATER_FUNCTION_DOCUMENTATION,
   "repeated-static-call-cases": REPEATED_STATIC_CALL_CASES_DOCUMENTATION,
   "require-assert-never": REQUIRE_ASSERT_NEVER_DOCUMENTATION,
   "require-button-accessible-name": REQUIRE_BUTTON_ACCESSIBLE_NAME_DOCUMENTATION,

package/dist/{chunk-4USNCXB3.js → chunk-UI4ADSAA.js}

@@ -16467,6 +16467,9 @@ var VIEWS = /* @__PURE__ */ new WeakMap();
 var DIRECT_EVAL = /* @__PURE__ */ new WeakMap();
 var REACT_IMPORTS = /* @__PURE__ */ new WeakMap();
 var PARAMETER_BINDINGS = /* @__PURE__ */ new WeakMap();
+function importsReactValue(source) {
+  return source.ast.body.some((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" && statement.importKind !== "type");
+}
 function renderFunction(node) {
   let parent = parentOf(node);
   while (parent !== null) {
@@ -16644,7 +16647,7 @@ var no_readonly_prop_state_default = defineRule({
         tsrs = null;
         pending = [];
         const source = context.sourceCode;
-        if (isGeneratedFile({ filename: context.filename, cwd: context.cwd }, source.text) || isTestFile({ filename: context.filename, cwd: context.cwd }) || !source.ast.body.some((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" && statement.importKind !== "type")) return false;
+        if (isGeneratedFile({ filename: context.filename, cwd: context.cwd }, source.text) || isTestFile({ filename: context.filename, cwd: context.cwd }) || !importsReactValue(source)) return false;
         tsrs = tsrsServices(context);
         return true;
       },
@@ -23411,6 +23414,94 @@ function literalTag(node) {
   return typeof node.value === "string" || typeof node.value === "number" || typeof node.value === "boolean" ? node.value : void 0;
 }
 
+// src/rules/_discriminated-union-projections.ts
+function projectedBooleanPairs(owner, returned2, source) {
+  if (owner.async || owner.generator || isPresent(owner.typeParameters) || owner.body?.type !== "BlockStatement" || parentOf(returned2) !== owner.body || owner.body.body.at(-1) !== returned2 || returned2.argument?.type !== "ObjectExpression") return [];
+  const contract = returnContract(owner, source);
+  const shape = contract === void 0 ? void 0 : objectContract(contract.members);
+  if (shape === void 0 || contract === void 0) return [];
+  const properties2 = returnedProperties([returned2.argument], shape)?.[0];
+  if (properties2 === void 0) return [];
+  const fields2 = [...shape.members].filter(([, member3]) => !member3.optional && booleanType(member3.typeAnnotation?.typeAnnotation, source));
+  if (fields2.length > 8) return [];
+  const comparisons = [];
+  for (const [field] of fields2) {
+    const value = properties2.get(field);
+    if (value?.type !== "BinaryExpression" || value.operator !== "===" || value.left.type !== "Identifier" || !constantSyntax(value.right, source)) continue;
+    const binding3 = localSnapshot(value.left, owner, source);
+    if (binding3 !== null) comparisons.push({ field, binding: binding3, left: value.left, right: value.right });
+  }
+  return comparisons.flatMap((left, index) => comparisons.slice(index + 1).filter((right) => right.binding === left.binding).map((right) => ({ reportNode: contract.reportNode, left, right })));
+}
+function localSnapshot(identifier, owner, source) {
+  const variable = findVariable(source.getScope(identifier), identifier.name);
+  const declaration = variable?.defs[0]?.node;
+  if (variable === null || variable.defs.length !== 1 || declaration?.type !== "VariableDeclarator" || !isConstDeclaration(parentOf(declaration)) || !isPresent(declaration.init) || enclosingFunction(declaration) !== owner || declaration.range[1] >= identifier.range[0] || !stableValueBinding(variable)) return null;
+  return variable;
+}
+function constantSyntax(node, source) {
+  if (node.type === "Literal") return typeof node.value === "string" || typeof node.value === "number" && Number.isFinite(node.value);
+  if (node.type !== "MemberExpression" || node.computed || node.optional || node.object.type !== "Identifier" || node.property.type !== "Identifier") return false;
+  const variable = findVariable(source.getScope(node.object), node.object.name);
+  const definition = variable?.defs[0]?.node;
+  if (variable === null || variable.defs.length !== 1 || definition?.type !== "TSEnumDeclaration" && definition?.type !== "ImportSpecifier" || !stableValueBinding(variable)) return false;
+  return variable.references.every((reference) => {
+    if (typeOnlyReference(reference)) return true;
+    const member3 = parentOf(reference.identifier);
+    if (member3?.type !== "MemberExpression" || member3.object !== reference.identifier || member3.computed || member3.optional || writtenMember(member3)) return false;
+    const use = parentOf(member3);
+    return !((use?.type === "CallExpression" || use?.type === "NewExpression") && use.callee === member3);
+  });
+}
+function enumConstant(node, native) {
+  if (node.type !== "MemberExpression") return false;
+  const root = native.node(node.object);
+  const member3 = native.node(node.property);
+  let symbol = root === void 0 ? void 0 : native.checker.getSymbolAtLocation(root);
+  if (symbol === void 0 || member3 === void 0) return false;
+  if ((symbol.flags & native.sync.SymbolFlags.Alias) !== 0) symbol = native.checker.getAliasedSymbol(symbol);
+  const declarations = symbol.declarations;
+  if (declarations.length !== 1 || declarations[0]?.kind !== native.ast.SyntaxKind.EnumDeclaration) return false;
+  const selected = native.checker.getSymbolAtLocation(member3)?.declarations;
+  return selected?.length === 1 && selected[0]?.kind === native.ast.SyntaxKind.EnumMember;
+}
+function projectedBooleanEvidence(file, candidates2) {
+  const nodes = candidates2.flatMap(({ left, right }) => [left.left, right.left, left.right, right.right]);
+  const types = file.typesOf(nodes);
+  const unions = types.flatMap((type) => type !== void 0 && type.isUnionType() ? [type] : []);
+  const lists = file.batch(unions.map((type) => type.getTypes.gen()));
+  let index = 0;
+  const domains = types.map((type) => type === void 0 ? void 0 : primitiveValues(type.isUnionType() ? lists[index++] ?? [] : [type], file));
+  const native = nativeTypes(file);
+  const constants = /* @__PURE__ */ new Map();
+  function constant(node, value) {
+    if (node.type === "Literal") return node.value === value;
+    let valid = constants.get(node);
+    if (valid === void 0) {
+      valid = enumConstant(node, native);
+      constants.set(node, valid);
+    }
+    return valid;
+  }
+  return candidates2.map(({ left, right }, ordinal) => {
+    const [a, b, x, y] = domains.slice(ordinal * 4, ordinal * 4 + 4);
+    const first = x?.[0];
+    const second = y?.[0];
+    return a !== void 0 && b !== void 0 && x?.length === 1 && y?.length === 1 && first !== void 0 && second !== void 0 && first !== second && constant(left.right, first) && constant(right.right, second) && a.includes(first) && a.includes(second) && b.includes(first) && b.includes(second);
+  });
+}
+function primitiveValues(types, file) {
+  if (types.length < 1 || types.length > 16) return void 0;
+  const values = [];
+  for (const type of types) {
+    if ((type.flags & (file.flags.StringLiteral | file.flags.NumberLiteral)) === 0) return void 0;
+    const value = type.value;
+    if (typeof value !== "string" && !(typeof value === "number" && Number.isFinite(value))) return void 0;
+    values.push(value);
+  }
+  return values;
+}
+
 // src/rules/prefer-discriminated-union.ts
 var NAME99 = "prefer-discriminated-union";
 var prefer_discriminated_union_default = defineRule({
@@ -23424,12 +23515,14 @@ var prefer_discriminated_union_default = defineRule({
     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.",
-      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."
+      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.",
+      preferProjectedState: "This producer compares the same immutable primitive snapshot with distinct state values for `{{fields}}`, but its Boolean return contract also permits true/true. Review returning the authoritative state or preserving every produced combination in a union. Keep independent dimensions and unknown states; other writers and readers of a shared contract require review."
     }
   },
   createOnce(context) {
     const reportedContracts = /* @__PURE__ */ new Set();
     const producers = [];
+    const returns = /* @__PURE__ */ new Map();
     function rememberProducer(node) {
       producers.push(node);
     }
@@ -23449,6 +23542,7 @@ var prefer_discriminated_union_default = defineRule({
       before() {
         reportedContracts.clear();
         producers.length = 0;
+        returns.clear();
         const file = { filename: context.filename, cwd: context.cwd };
         if (isTestFile(file) || isGeneratedFile(file, context.sourceCode.text)) return false;
         return void 0;
@@ -23456,8 +23550,28 @@ var prefer_discriminated_union_default = defineRule({
       ArrowFunctionExpression: rememberProducer,
       FunctionDeclaration: rememberProducer,
       FunctionExpression: rememberProducer,
+      ReturnStatement(node) {
+        const owner = enclosingFunction(node);
+        if (owner !== null) returns.set(owner, returns.has(owner) ? null : node);
+      },
       "Program:exit"() {
         for (const producer of producers) checkProducer(producer);
+        if (hasIdentifierNamed(context.sourceCode, "eval")) return;
+        const candidates2 = [];
+        for (const producer of producers) {
+          const returned2 = returns.get(producer);
+          if (!isPresent(returned2)) continue;
+          candidates2.push(...projectedBooleanPairs(producer, returned2, context.sourceCode).filter(({ reportNode }) => !reportedContracts.has(reportNode)));
+          if (candidates2.length > 128) return;
+        }
+        if (candidates2.length === 0) return;
+        const evidence = tsrsServices(context)?.run((file) => projectedBooleanEvidence(file, candidates2));
+        if (!isPresent(evidence)) return;
+        candidates2.forEach(({ reportNode, left, right }, index) => {
+          if (evidence[index] !== true || reportedContracts.has(reportNode)) return;
+          reportedContracts.add(reportNode);
+          context.report({ node: reportNode, messageId: "preferProjectedState", data: { fields: [left.field, right.field].join("`, `") } });
+        });
       }
     };
   }
@@ -31806,8 +31920,62 @@ var production_derived_test_cases_default = defineRule({
   }
 });
 
+// src/rules/react-prefer-updater-function.ts
+var NAME131 = "react-prefer-updater-function";
+function stateForSetter(source, setter) {
+  const declarator = setter.defs[0]?.node;
+  if (setter.defs.length !== 1 || declarator?.type !== "VariableDeclarator" || declarator.id.type !== "ArrayPattern" || declarator.init === null) return null;
+  const [value, update] = declarator.id.elements;
+  const call = unwrapExpression(declarator.init);
+  if (value?.type !== "Identifier" || update?.type !== "Identifier" || !setter.identifiers.includes(update) || call.type !== "CallExpression" || !reactHook(source, call.callee, "useState") || !stableValueBinding(setter)) return null;
+  const state = source.getDeclaredVariables(declarator).find((variable) => variable.identifiers.includes(value));
+  return state !== void 0 && stableValueBinding(state) ? { state, owner: enclosingFunction(declarator) } : null;
+}
+function readsStateEagerly(state, argument) {
+  return state.references.some((reference) => reference.isRead() && !typeOnlyReference(reference) && evaluatedBy(reference.identifier, argument));
+}
+function evaluatedBy(node, argument) {
+  for (let current = node; current !== null && !isFunction(current); current = parentOf(current)) {
+    if (current === argument) return true;
+  }
+  return false;
+}
+function isFunction(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
+}
+var react_prefer_updater_function_default = defineRule({
+  meta: {
+    type: "problem",
+    docs: { description: "Use the updater form when the next React state is built from the current state.", url: docsUrl(NAME131) },
+    schema: [],
+    messages: {
+      preferUpdaterFunction: "`{{setter}}` builds the next state from the `{{state}}` snapshot, which is stale after an await, in timers and effects, or when two updates run before a re-render. Pass an updater: `{{setter}}((previous) => ...)`, reading `previous` wherever the argument read `{{state}}` or a value derived from it. Compute impure values such as IDs or timestamps before the call so the updater stays pure."
+    }
+  },
+  createOnce(context) {
+    return {
+      before() {
+        const source = context.sourceCode;
+        return !isGeneratedFile({ filename: context.filename, cwd: context.cwd }, source.text) && importsReactValue(source);
+      },
+      CallExpression(node) {
+        const [argument] = node.arguments;
+        const callee = unwrapExpression(node.callee);
+        if (node.arguments.length !== 1 || argument === void 0 || argument.type === "SpreadElement" || callee.type !== "Identifier") return;
+        const value = unwrapExpression(argument);
+        if (value.type === "Identifier" || isFunction(value)) return;
+        const source = context.sourceCode;
+        const setter = findVariable(source.getScope(callee), callee.name);
+        const binding3 = setter === null ? null : stateForSetter(source, setter);
+        if (setter === null || binding3 === null || enclosingFunction(node) === binding3.owner || !readsStateEagerly(binding3.state, argument)) return;
+        context.report({ node, messageId: "preferUpdaterFunction", data: { setter: setter.name, state: binding3.state.name } });
+      }
+    };
+  }
+});
+
 // src/rules/repeated-static-call-cases.ts
-var NAME131 = "repeated-static-call-cases";
+var NAME132 = "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"]);
@@ -31931,7 +32099,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(NAME131)
+      url: docsUrl(NAME132)
     },
     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." }
@@ -32074,7 +32242,7 @@ function isPrimitiveReturn(node, annotation) {
 }
 
 // src/rules/require-assert-never.ts
-var NAME132 = "require-assert-never";
+var NAME133 = "require-assert-never";
 function isRuntimeHandlingStatement(statement) {
   if (statement.type === "EmptyStatement") return false;
   if (statement.type === "BreakStatement") return statement.label !== null;
@@ -32144,7 +32312,7 @@ var require_assert_never_default = defineRule({
     fixable: "code",
     docs: {
       description: "Require a never witness in empty switch defaults so discriminated unions remain exhaustive at compile time.",
-      url: docsUrl(NAME132)
+      url: docsUrl(NAME133)
     },
     schema: [],
     messages: {
@@ -32188,7 +32356,7 @@ var require_assert_never_default = defineRule({
 });
 
 // src/rules/require-button-accessible-name.ts
-var NAME133 = "require-button-accessible-name";
+var NAME134 = "require-button-accessible-name";
 var DELEGATING_PROPS = /* @__PURE__ */ new Set(["render", "asChild"]);
 function delegatesRendering(opening) {
   return opening.attributes.some(
@@ -32201,7 +32369,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(NAME133)
+      url: docsUrl(NAME134)
     },
     schema: [
       {
@@ -32255,7 +32423,7 @@ var require_button_accessible_name_default = defineRule({
 });
 
 // src/rules/require-camelcase-properties.ts
-var NAME134 = "require-camelcase-properties";
+var NAME135 = "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;
@@ -32269,7 +32437,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(NAME134)
+      url: docsUrl(NAME135)
     },
     schema: [],
     defaultOptions: [],
@@ -32333,7 +32501,7 @@ var require_camelcase_properties_default = defineRule({
 });
 
 // src/rules/require-constrained-schema-integer.ts
-var NAME135 = "require-constrained-schema-integer";
+var NAME136 = "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"]);
@@ -32375,7 +32543,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(NAME135)
+      url: docsUrl(NAME136)
     },
     schema: [],
     messages: { constrainInteger: "Declare `{{field}}` as an integer with a lower bound of {{minimum}} or greater, or reuse its named domain schema." }
@@ -32854,14 +33022,14 @@ function closedNominalInheritanceFix(sourceCode2, file, call, consumer, implemen
 }
 
 // src/rules/require-explicit-contract-implementation.ts
-var NAME136 = "require-explicit-contract-implementation";
+var NAME137 = "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(NAME136)
+      url: docsUrl(NAME137)
     },
     schema: [],
     messages: {
@@ -33552,7 +33720,7 @@ function abstractContractOperations(node, functionAliases) {
 }
 
 // src/rules/require-explicit-service-contract.ts
-var NAME137 = "require-explicit-service-contract";
+var NAME138 = "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;
@@ -33568,7 +33736,7 @@ var require_explicit_service_contract_default = defineRule({
     type: "problem",
     docs: {
       description: "Require explicit contracts for classes that invoke retained collaborators.",
-      url: docsUrl(NAME137)
+      url: docsUrl(NAME138)
     },
     schema: [],
     fixable: "code",
@@ -33604,7 +33772,7 @@ var require_explicit_service_contract_default = defineRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var NAME138 = "require-fetch-timeout";
+var NAME139 = "require-fetch-timeout";
 function emptySignal(expression, resolvesToGlobal) {
   const value = unwrapExpression(expression);
   if (value.type === "Literal" && value.value === null)
@@ -33666,7 +33834,7 @@ var require_fetch_timeout_default = defineRule({
     type: "problem",
     docs: {
       description: "Require an explicit abort signal on locally analyzable global fetch calls.",
-      url: docsUrl(NAME138)
+      url: docsUrl(NAME139)
     },
     schema: [
       {
@@ -33758,13 +33926,13 @@ var require_fetch_timeout_default = defineRule({
 });
 
 // src/rules/require-ime-safe-enter-handler.ts
-var NAME139 = "require-ime-safe-enter-handler";
+var NAME140 = "require-ime-safe-enter-handler";
 var require_ime_safe_enter_handler_default = defineRule({
   meta: {
     type: "problem",
     docs: {
       description: "Preserve IME composition before Enter submits or blurs a native text control.",
-      url: docsUrl(NAME139)
+      url: docsUrl(NAME140)
     },
     schema: [],
     messages: {
@@ -33840,7 +34008,7 @@ function nativeAction(node, event) {
 }
 
 // src/rules/require-interface-for-exported-class.ts
-var NAME140 = "require-interface-for-exported-class";
+var NAME141 = "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";
@@ -33901,7 +34069,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(NAME140)
+      url: docsUrl(NAME141)
     },
     schema: [],
     fixable: "code",
@@ -33943,7 +34111,7 @@ var require_interface_for_exported_class_default = defineRule({
 });
 
 // src/rules/require-jwt-lifetime.ts
-var NAME141 = "require-jwt-lifetime";
+var NAME142 = "require-jwt-lifetime";
 function isJoseValueImport(declaration) {
   return declaration.type === "ImportDeclaration" && declaration.importKind !== "type" && declaration.source.value === "jose";
 }
@@ -33952,7 +34120,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(NAME141)
+      url: docsUrl(NAME142)
     },
     schema: [],
     messages: { lifetime: "Require the JWT exp claim or set maxTokenAge before returning this verification result." }
@@ -34011,7 +34179,7 @@ var require_jwt_lifetime_default = defineRule({
 });
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var NAME142 = "require-pascal-case-zod-schema-name";
+var NAME143 = "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([
@@ -34182,7 +34350,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(NAME142)
+      url: docsUrl(NAME143)
     },
     schema: [],
     defaultOptions: [],
@@ -34292,7 +34460,7 @@ var require_pascal_case_zod_schema_name_default = defineRule({
 });
 
 // src/rules/require-port-for-service.ts
-var NAME143 = "require-port-for-service";
+var NAME144 = "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$/;
@@ -34426,7 +34594,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(NAME143)
+      url: docsUrl(NAME144)
     },
     schema: [],
     fixable: "code",
@@ -34466,7 +34634,7 @@ var require_port_for_service_default = defineRule({
 });
 
 // src/rules/require-sql-access-class.ts
-var NAME144 = "require-sql-access-class";
+var NAME145 = "require-sql-access-class";
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -34664,7 +34832,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(NAME144)
+      url: docsUrl(NAME145)
     },
     schema: [],
     messages: {
@@ -34736,7 +34904,7 @@ function staticMatcherFix(sourceCode2, property) {
 }
 
 // src/rules/require-static-next-matcher.ts
-var NAME145 = "require-static-next-matcher";
+var NAME146 = "require-static-next-matcher";
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function isStaticValue(node) {
   const value = unwrapExpression(node);
@@ -34768,7 +34936,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(NAME145)
+      url: docsUrl(NAME146)
     },
     schema: [],
     messages: {
@@ -34812,7 +34980,7 @@ var require_static_next_matcher_default = defineRule({
 });
 
 // src/rules/require-svg-accessible-name.ts
-var NAME146 = "require-svg-accessible-name";
+var NAME147 = "require-svg-accessible-name";
 var DECORATIVE_ROLES = /* @__PURE__ */ new Set(["none", "presentation"]);
 var NAME_ATTRIBUTES = ["aria-label", "aria-labelledby"];
 var NO_ICON_MODULES = [];
@@ -34821,7 +34989,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(NAME146)
+      url: docsUrl(NAME147)
     },
     schema: [],
     messages: {
@@ -34853,7 +35021,7 @@ var require_svg_accessible_name_default = defineRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var NAME147 = "require-use-form-default-values";
+var NAME148 = "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);
@@ -34896,7 +35064,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(NAME147)
+      url: docsUrl(NAME148)
     },
     schema: [],
     messages: { requireUseFormDefaultValues: "Add non-undefined defaultValues/values to the associated useForm call or non-undefined defaultValue to this field." }
@@ -35035,7 +35203,7 @@ var require_use_form_default_values_default = defineRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var NAME148 = "require-use-server-in-actions-file";
+var NAME149 = "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";
@@ -35056,7 +35224,7 @@ var require_use_server_in_actions_file_default = defineRule({
     type: "problem",
     docs: {
       description: "route action module missing the use server directive",
-      url: docsUrl(NAME148)
+      url: docsUrl(NAME149)
     },
     schema: [],
     messages: {
@@ -35082,7 +35250,7 @@ var require_use_server_in_actions_file_default = defineRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var NAME149 = "require-zod-form-validation";
+var NAME150 = "require-zod-form-validation";
 var ZOD_PARSE_METHODS = /* @__PURE__ */ new Set([
   "parse",
   "safeParse",
@@ -35141,7 +35309,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(NAME149)
+      url: docsUrl(NAME150)
     },
     schema: [],
     messages: {
@@ -35429,7 +35597,7 @@ function declaresFramework(metadata, name) {
 }
 
 // src/rules/sole-export-matches-filename.ts
-var NAME150 = "sole-export-matches-filename";
+var NAME151 = "sole-export-matches-filename";
 var EXCLUDED_STEMS = /* @__PURE__ */ new Set(["global", "index", "types"]);
 function stem3(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
@@ -35443,7 +35611,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(NAME150)
+      url: docsUrl(NAME151)
     },
     schema: [],
     messages: {
@@ -35497,7 +35665,7 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/stepdown.ts
-function isFunction(node) {
+function isFunction2(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
 function isErasedExpression2(node) {
@@ -35520,7 +35688,7 @@ function wrappedExpression(node) {
 function enclosingFunction2(node) {
   let current = parentOf(node);
   while (current !== null) {
-    if (isFunction(current)) return current;
+    if (isFunction2(current)) return current;
     current = parentOf(current);
   }
   return void 0;
@@ -35779,7 +35947,7 @@ function isDeferredModuleStatement(statement) {
   if (node === null || node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration" || node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "EmptyStatement") {
     return true;
   }
-  return node.type === "VariableDeclaration" && node.declarations.every((declaration) => declaration.id.type === "Identifier" && declaration.init !== null && isFunction(unwrapExpression4(declaration.init)));
+  return node.type === "VariableDeclaration" && node.declarations.every((declaration) => declaration.id.type === "Identifier" && declaration.init !== null && isFunction2(unwrapExpression4(declaration.init)));
 }
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
@@ -35820,7 +35988,7 @@ function moduleDefinitions(program) {
 }
 function constFunctionDefinition(declarator) {
   const initializer = declarator.init === null ? null : unwrapExpression4(declarator.init);
-  if (declarator.id.type !== "Identifier" || initializer === null || !isFunction(initializer)) return [];
+  if (declarator.id.type !== "Identifier" || initializer === null || !isFunction2(initializer)) return [];
   const { name } = declarator.id;
   return [{ key: name, name, node: declarator, functionNode: initializer, bindingNode: declarator }];
 }
@@ -35899,7 +36067,7 @@ function referencedPropertyName(node) {
 }
 function walk3(node, visitorKeys, visit2, nestedFunction = false) {
   visit2(node, nestedFunction);
-  const nested = nestedFunction || isFunction(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression";
+  const nested = nestedFunction || isFunction2(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression";
   forEachAstChild(node, visitorKeys, (child) => {
     walk3(child, visitorKeys, visit2, nested);
   });
@@ -35920,7 +36088,7 @@ function classScope(state, node, computedReferences, privateBandOnly) {
   const visitorKeys = state.sourceCode.visitorKeys;
   const methods = node.body.body.flatMap((member3) => member3.type === "MethodDefinition" ? [member3] : []);
   const counts = classMethodCounts(node.body, methods);
-  const implementations = methods.filter((method) => isFunction(method.value));
+  const implementations = methods.filter((method) => isFunction2(method.value));
   const implementationCounts = classMethodCounts(node.body, implementations);
   const scopeDefinitions = implementations.flatMap((method) => {
     const name = methodName(method);
@@ -35958,7 +36126,7 @@ function classScope(state, node, computedReferences, privateBandOnly) {
       return;
     }
     const methodFunction = method.value;
-    if (!isFunction(methodFunction) || methodFunction.body === null) return;
+    if (!isFunction2(methodFunction) || methodFunction.body === null) return;
     const body3 = methodFunction.body;
     const caller = methodKey(name, method.static);
     const receivers = new Map(classReceivers);
@@ -36186,7 +36354,7 @@ var stepdown_default = defineRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var NAME151 = "store-insert-requires-on-conflict";
+var NAME152 = "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;
@@ -36215,7 +36383,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(NAME151)
+      url: docsUrl(NAME152)
     },
     schema: [],
     messages: {
@@ -36240,7 +36408,7 @@ var store_insert_requires_on_conflict_default = defineRule({
 });
 
 // src/rules/test-loops-over-literal-cases.ts
-var NAME152 = "test-loops-over-literal-cases";
+var NAME153 = "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([
@@ -36336,7 +36504,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(NAME152)
+      url: docsUrl(NAME153)
     },
     schema: [],
     messages: {
@@ -36400,7 +36568,7 @@ var test_loops_over_literal_cases_default = defineRule({
 });
 
 // src/rules/test-phase-label-comment.ts
-var NAME153 = "test-phase-label-comment";
+var NAME154 = "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}$`,
@@ -36428,7 +36596,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(NAME153)
+      url: docsUrl(NAME154)
     },
     schema: [],
     messages: { removeLabel: "Bare test phase label \u2014 delete it and let the test names and helpers carry the structure." }
@@ -36611,6 +36779,7 @@ var RULES = {
   "prefer-zod-infer": prefer_zod_infer_default,
   "prefer-zod-parse-output-type": prefer_zod_parse_output_type_default,
   "production-derived-test-cases": production_derived_test_cases_default,
+  "react-prefer-updater-function": react_prefer_updater_function_default,
   "repeated-static-call-cases": repeated_static_call_cases_default,
   "require-assert-never": require_assert_never_default,
   "require-button-accessible-name": require_button_accessible_name_default,

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-4USNCXB3.js";
+} from "./chunk-UI4ADSAA.js";
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "19.17.0",
+  "version": "19.19.0",
   "packageManager": "npm@12.2.1",
   "description": "Custom Oxlint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",