@isentinel/eslint-config 6.0.0-beta.37 → 6.0.0-beta.39

package/dist/cli.mjs

@@ -9,7 +9,7 @@ import path from "node:path";
 import { existsSync, readFileSync } from "fs";
 import { execSync } from "node:child_process";
 //#region package.json
-var version = "6.0.0-beta.37";
+var version = "6.0.0-beta.39";
 var package_default = {
 	name: "@isentinel/eslint-config",
 	version,

package/dist/index.d.mts

@@ -10976,399 +10976,502 @@ interface RuleOptions {
   'sentinel/prefer-math-min-max'?: Linter.RuleEntry<[]>;
   /**
    * Disallow bracket array type syntax and require Array<T> / ReadonlyArray<T>.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/array-type-generic/
    */
   'small-rules/array-type-generic'?: Linter.RuleEntry<[]>;
   /**
    * Ban specified Roblox Instance classes and configured Instance properties.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/ban-instances/
    */
   'small-rules/ban-instances'?: Linter.RuleEntry<SmallRulesBanInstances>;
   /**
    * Ban React.FC and similar component type annotations. Use explicit function declarations instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/ban-react-fc/
    */
   'small-rules/ban-react-fc'?: Linter.RuleEntry<[]>;
   /**
    * Ban configured TypeScript utility types, defaulting to Omit in favor of Except.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/ban-types/
    */
   'small-rules/ban-types'?: Linter.RuleEntry<SmallRulesBanTypes>;
   /**
    * Enforce consistent spelling of compound words in identifiers.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/consistent-compound-words/
    */
   'small-rules/consistent-compound-words'?: Linter.RuleEntry<SmallRulesConsistentCompoundWords>;
   /**
    * Require a matching enable comment for every `oxlint-disable` or `eslint-disable` block directive.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-disable-enable-pair/
    */
   'small-rules/directive-disable-enable-pair'?: Linter.RuleEntry<SmallRulesDirectiveDisableEnablePair>;
   /**
    * Disallow aggregating `oxlint-enable` or `eslint-enable` comments across multiple disable directives.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-aggregating-enable/
    */
   'small-rules/directive-no-aggregating-enable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow duplicate `oxlint-disable` or `eslint-disable` comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-duplicate-disable/
    */
   'small-rules/directive-no-duplicate-disable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow `oxlint-disable` or `eslint-disable` comments for configured rules.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-restricted-disable/
    */
   'small-rules/directive-no-restricted-disable'?: Linter.RuleEntry<SmallRulesDirectiveNoRestrictedDisable>;
   /**
    * Disallow `oxlint-disable` or `eslint-disable` comments without rule names.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-unlimited-disable/
    */
   'small-rules/directive-no-unlimited-disable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow unused `oxlint-enable` or `eslint-enable` comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-unused-enable/
    */
   'small-rules/directive-no-unused-enable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow block ESLint/Oxlint directive comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-use/
    */
   'small-rules/directive-no-use'?: Linter.RuleEntry<SmallRulesDirectiveNoUse>;
   /**
    * Require descriptions for `oxlint` and `eslint` disable/enable directives.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-require-description/
    */
   'small-rules/directive-require-description'?: Linter.RuleEntry<SmallRulesDirectiveRequireDescription>;
   /**
    * Enforce Ianitor.Check<T> type annotations on complex TypeScript types
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/enforce-ianitor-check-type/
    */
   'small-rules/enforce-ianitor-check-type'?: Linter.RuleEntry<SmallRulesEnforceIanitorCheckType>;
   /**
    * Prevent usage of variables from outside the scope of isolated functions.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/isolated-functions/
    */
   'small-rules/isolated-functions'?: Linter.RuleEntry<SmallRulesIsolatedFunctions>;
   /**
    * Flags effect dependencies that are not memoized. Unmemoized dependencies can cause unnecessary re-renders or infinite loops.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/memoized-effect-dependencies/
    */
   'small-rules/memoized-effect-dependencies'?: Linter.RuleEntry<SmallRulesMemoizedEffectDependencies>;
   /**
    * Disallow array constructor element forms and enforce roblox-ts-aware constructor patterns.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-constructor-elements/
    */
   'small-rules/no-array-constructor-elements'?: Linter.RuleEntry<SmallRulesNoArrayConstructorElements>;
   /**
    * Disallow new Array<T>() followed by contiguous index assignments; use an array literal instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-constructor-index-assignment/
    */
   'small-rules/no-array-constructor-index-assignment'?: Linter.RuleEntry<[]>;
   /**
    * Disallow array append assignments using array[array.size()] = value (roblox-ts) or array[array.length] = value (standard) and prefer push-based appends.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-size-assignment/
    */
   'small-rules/no-array-size-assignment'?: Linter.RuleEntry<SmallRulesNoArraySizeAssignment>;
   /**
    * Disallow asynchronous operations inside class constructors. Constructors return immediately, so async work causes race conditions, unhandled rejections, and incomplete object states.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-async-constructor/
    */
   'small-rules/no-async-constructor'?: Linter.RuleEntry<[]>;
   /**
    * Disallow yielding Roblox API calls in synchronous Planck system execution.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-async-in-system/
    */
   'small-rules/no-async-in-system'?: Linter.RuleEntry<SmallRulesNoAsyncInSystem>;
   /**
    * Disallow effect hooks with many cascading state updates.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-cascading-set-state/
    */
   'small-rules/no-cascading-set-state'?: Linter.RuleEntry<[]>;
   /**
    * Ban new Color3(...) except new Color3() or new Color3(0, 0, 0). Use Color3.fromRGB() instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-color3-constructor/
    */
   'small-rules/no-color3-constructor'?: Linter.RuleEntry<SmallRulesNoColor3Constructor>;
   /**
    * Disallow commented-out code
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-commented-code/
    */
   'small-rules/no-commented-code'?: Linter.RuleEntry<SmallRulesNoCommentedCode>;
   /**
    * Disallow constant conditions, but allow constant loops that include loop exits such as break, return, or configured calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-constant-condition-with-break/
    */
   'small-rules/no-constant-condition-with-break'?: Linter.RuleEntry<SmallRulesNoConstantConditionWithBreak>;
   /**
    * Disallow assignments whose value is never read.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-dead-store/
    */
   'small-rules/no-dead-store'?: Linter.RuleEntry<[]>;
   /**
    * Use throw instead of error().
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-error/
    */
   'small-rules/no-error'?: Linter.RuleEntry<[]>;
   /**
    * Disallow sending Events back to the same player inside an Events.connect callback; use Functions for request/response.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-events-in-events-callback/
    */
   'small-rules/no-events-in-events-callback'?: Linter.RuleEntry<SmallRulesNoEventsInEventsCallback>;
   /**
    * Disallow map(...) directly after filter(...).
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-filter-map-chain/
    */
   'small-rules/no-filter-map-chain'?: Linter.RuleEntry<[]>;
   /**
    * Disallow exact comparisons involving inexact floating-point values.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-floating-point-equality/
    */
   'small-rules/no-floating-point-equality'?: Linter.RuleEntry<[]>;
   /**
    * Report React components whose bodies exceed 300 lines.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-giant-component/
    */
   'small-rules/no-giant-component'?: Linter.RuleEntry<[]>;
   /**
    * Enforce React component size and complexity limits inspired by the 'Refactor God Component' checklist.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-god-components/
    */
   'small-rules/no-god-components'?: Linter.RuleEntry<SmallRulesNoGodComponents>;
   /**
    * Disallow Ianitor validator creation inside function bodies. Hoist to module scope to avoid recreating validators on every call.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-ianitor-in-function-body/
    */
   'small-rules/no-ianitor-in-function-body'?: Linter.RuleEntry<[]>;
   /**
    * Disallow accessing `.success` on Ianitor check results when the full result object is not needed.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-ianitor-success-access/
    */
   'small-rules/no-ianitor-success-access'?: Linter.RuleEntry<[]>;
   /**
    * Disallow pointless identity `.map()` calls that return the parameter unchanged
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-identity-map/
    */
   'small-rules/no-identity-map'?: Linter.RuleEntry<SmallRulesNoIdentityMap>;
   /**
    * Disallow standalone `++` and `--` statements and for-loop update clauses.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-increment-decrement/
    */
   'small-rules/no-increment-decrement'?: Linter.RuleEntry<SmallRulesNoIncrementDecrement>;
   /**
    * Prevent inline properties from being passed to memoized components.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-inline-property-on-memo-component/
    */
   'small-rules/no-inline-property-on-memo-component'?: Linter.RuleEntry<[]>;
   /**
    * Detect instance methods that do not use 'this' and suggest converting them to standalone functions for better performance in roblox-ts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-instance-methods-without-this/
    */
   'small-rules/no-instance-methods-without-this'?: Linter.RuleEntry<SmallRulesNoInstanceMethodsWithoutThis>;
   /**
    * Disallow mutating a loop iterable during iteration.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-loop-iterable-mutation/
    */
   'small-rules/no-loop-iterable-mutation'?: Linter.RuleEntry<[]>;
   /**
    * Disallow spreading static property bags into nativeProperties/*NativeProperties props and onto JSX elements via intermediate objects, because the spread creates a new copied table every render.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-native-properties-spread/
    */
   'small-rules/no-native-properties-spread'?: Linter.RuleEntry<[]>;
   /**
    * Disallow configured constructor calls (default: new Instance) inside React useMemo callbacks.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-new-instance-in-use-memo/
    */
   'small-rules/no-new-instance-in-use-memo'?: Linter.RuleEntry<SmallRulesNoNewInstanceInUseMemo>;
   /**
    * Use Log instead of print().
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-print/
    */
   'small-rules/no-print'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallow recursive function calls to prevent stack overflow.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-recursive/
+   */
   'small-rules/no-recursive'?: Linter.RuleEntry<SmallRulesNoRecursive>;
   /**
    * Disallow redundant uiaspectratioconstraint children inside components that already manage their own aspect ratio internally.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-redundant-aspect-ratio-constraint/
    */
   'small-rules/no-redundant-aspect-ratio-constraint'?: Linter.RuleEntry<[]>;
   /**
    * Disallow non-component functions that return JSX or React elements.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-render-helper-functions/
    */
   'small-rules/no-render-helper-functions'?: Linter.RuleEntry<[]>;
   /**
    * Disallow assignment to restricted object properties.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-restricted-property-assignment/
    */
   'small-rules/no-restricted-property-assignment'?: Linter.RuleEntry<SmallRulesNoRestrictedPropertyAssignment>;
   /**
    * Disallow the .spec.{ts,tsx} file extension for test files. Use .test.{ts,tsx} instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/no-spec-file-extension/
    */
   'small-rules/no-spec-file-extension'?: Linter.RuleEntry<[]>;
   /**
    * Require JSX for static React.createElement calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-static-react-create-element/
    */
   'small-rules/no-static-react-create-element'?: Linter.RuleEntry<SmallRulesNoStaticReactCreateElement>;
   /**
    * Disallow map(...) directly on table.create(...) and new Array(...) constructor patterns in roblox-ts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-table-create-map/
    */
   'small-rules/no-table-create-map'?: Linter.RuleEntry<[]>;
   /**
    * Disallow task.wait() and Promise.delay(...).await() calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-task-wait/
    */
   'small-rules/no-task-wait'?: Linter.RuleEntry<[]>;
   /**
    * Disallow assertions that always succeed or compare against freshly created values.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-trivial-assertions/
    */
   'small-rules/no-trivial-assertions'?: Linter.RuleEntry<[]>;
   /**
    * Ban React property names that begin with an underscore in JSX.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-underscore-react-props/
    */
   'small-rules/no-underscore-react-props'?: Linter.RuleEntry<[]>;
   /**
    * Disallow unused imports
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-unused-imports/
    */
   'small-rules/no-unused-imports'?: Linter.RuleEntry<SmallRulesNoUnusedImports>;
   /**
    * Disallow standalone useMemo calls that ignore the memoized value.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-unused-use-memo/
    */
   'small-rules/no-unused-use-memo'?: Linter.RuleEntry<SmallRulesNoUnusedUseMemo>;
   /**
    * Disallow useMemo for expressions that are already trivial to compute.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-use-memo-simple-expression/
    */
   'small-rules/no-use-memo-simple-expression'?: Linter.RuleEntry<[]>;
   /**
    * Disallow using the return value of functions that do not return anything.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-use-of-empty-return-value/
    */
   'small-rules/no-use-of-empty-return-value'?: Linter.RuleEntry<[]>;
   /**
    * Disallow constants that do not add value.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-useless-constants/
    */
   'small-rules/no-useless-constants'?: Linter.RuleEntry<SmallRulesNoUselessConstants>;
   /**
    * Disallow Roblox JSX properties whose values already match the class defaults.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-useless-default/
    */
   'small-rules/no-useless-default'?: Linter.RuleEntry<[]>;
   /**
    * Disallow empty effects, duplicate dependencies, effect chains, log-only effects, derived state, external-store state sync, state initialization, reset effects, parent notifications, parent ref callbacks, and event side effects routed through state.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-effect/
    */
   'small-rules/no-useless-use-effect'?: Linter.RuleEntry<SmallRulesNoUselessUseEffect>;
   /**
    * Disallow useMemo calls that only wrap values static enough to live at module scope.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-memo/
    */
   'small-rules/no-useless-use-memo'?: Linter.RuleEntry<SmallRulesNoUselessUseMemo>;
   /**
    * Disallow useSpring hooks whose config and dependencies are entirely static
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-spring/
    */
   'small-rules/no-useless-use-spring'?: Linter.RuleEntry<SmallRulesNoUselessUseSpring>;
   /**
    * Disallow spreading a potentially unbounded array into a variadic call, because every element becomes a stack-allocated argument.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-variadic-spread/
    */
   'small-rules/no-variadic-spread'?: Linter.RuleEntry<[]>;
   /**
    * Use Log instead of warn().
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-warn/
    */
   'small-rules/no-warn'?: Linter.RuleEntry<[]>;
   /**
    * Require all imports to be type-only imports. Benchmarks cannot import non-types because the benchmarker plugin will throw an error.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/only-type-imports/
    */
   'small-rules/only-type-imports'?: Linter.RuleEntry<[]>;
   /**
    * Prefer class properties to assignment of literals in constructors.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-class-properties/
    */
   'small-rules/prefer-class-properties'?: Linter.RuleEntry<SmallRulesPreferClassProperties>;
   /**
    * Disallow inline useReducer action objects that could be module-level constants.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-constant-dispatch/
    */
   'small-rules/prefer-constant-dispatch'?: Linter.RuleEntry<[]>;
   /**
    * Prefer a local ContextStack component over directly nesting multiple context providers.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-context-stack/
    */
   'small-rules/prefer-context-stack'?: Linter.RuleEntry<[]>;
   /**
    * Prefer importing React hooks directly instead of calling them via the React namespace.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-direct-hook-imports/
    */
   'small-rules/prefer-direct-hook-imports'?: Linter.RuleEntry<SmallRulesPreferDirectHookImports>;
   /**
    * Prefer early returns over full-body conditional wrapping.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-early-return/
    */
   'small-rules/prefer-early-return'?: Linter.RuleEntry<SmallRulesPreferEarlyReturn>;
   /**
    * Enforce expect assertion guards in tests and prefer expect.assertions(n) over expect.hasAssertions() when the count is known.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-expect-assertions/
    */
   'small-rules/prefer-expect-assertions'?: Linter.RuleEntry<SmallRulesPreferExpectAssertions>;
   /**
    * Prefer extracting static JSX elements to module-level constants.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-hoisted-jsx-elements/
    */
   'small-rules/prefer-hoisted-jsx-elements'?: Linter.RuleEntry<SmallRulesPreferHoistedJsxElements>;
   /**
    * Prefer extracting inline JSX object props to module-level constants when the entire object is statically hoistable.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-hoisted-jsx-object-properties/
    */
   'small-rules/prefer-hoisted-jsx-object-properties'?: Linter.RuleEntry<[]>;
   /**
-   * Prefer .idiv() for integer division instead of math.floor(x / y).
+   * Prefer .idiv() for integer division instead of math.floor(x / y) or math.floor(x * 0.5).
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-idiv/
    */
   'small-rules/prefer-idiv'?: Linter.RuleEntry<[]>;
   /**
    * Prefer a local Portal component over direct createPortal calls when the project already defines one.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-local-portal-component/
    */
   'small-rules/prefer-local-portal-component'?: Linter.RuleEntry<[]>;
   /**
    * Prefer math.min() and math.max() over simple clamp-like ternaries.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-math-min-max/
    */
   'small-rules/prefer-math-min-max'?: Linter.RuleEntry<[]>;
   /**
    * Prefer Modding.inspect over manually enumerating every enum member in a Record<Enum, true>.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-modding-inspect/
    */
   'small-rules/prefer-modding-inspect'?: Linter.RuleEntry<[]>;
   /**
    * Prefer screaming snake case constants at module scope or the allowed top-level wrapper scope.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-module-scope-constants/
    */
   'small-rules/prefer-module-scope-constants'?: Linter.RuleEntry<[]>;
   /**
    * Prefer local EqualPadding and DirectionalPadding components over matching <uipadding /> declarations.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-padding-components/
    */
   'small-rules/prefer-padding-components'?: Linter.RuleEntry<[]>;
   /**
    * Enforce PascalCase names for enums and enum members.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prefer-pascal-case-enums/
    */
   'small-rules/prefer-pascal-case-enums'?: Linter.RuleEntry<[]>;
   /**
    * Prefer direct ColorSequence and NumberSequence overloads over identical direct arguments and two-keypoint arrays.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-sequence-overloads/
    */
   'small-rules/prefer-sequence-overloads'?: Linter.RuleEntry<[]>;
   /**
    * Enforce combining multiple world.get() or world.has() calls into a single call for better Jecs performance.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-single-world-query/
    */
   'small-rules/prefer-single-world-query'?: Linter.RuleEntry<[]>;
   /**
    * Prefer singular naming for enums.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prefer-singular-enums/
    */
   'small-rules/prefer-singular-enums'?: Linter.RuleEntry<[]>;
   /**
    * Prefer ternary expressions over complementary JSX && branches.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-ternary-conditional-rendering/
    */
   'small-rules/prefer-ternary-conditional-rendering'?: Linter.RuleEntry<[]>;
   /**
    * Prefer UDim2.fromScale() or UDim2.fromOffset() over new UDim2() when all offsets or all scales are zero.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-udim2-shorthand/
    */
   'small-rules/prefer-udim2-shorthand'?: Linter.RuleEntry<[]>;
   /**
    * Suggest using useReducer for related state updates instead of multiple useState calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-use-reducer/
    */
   'small-rules/prefer-use-reducer'?: Linter.RuleEntry<[]>;
   /**
    * Prevent abbreviations.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prevent-abbreviations/
    */
   'small-rules/prevent-abbreviations'?: Linter.RuleEntry<SmallRulesPreventAbbreviations>;
   /**
    * Restrict React hooks to object returns or short tuples.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/react-hooks-strict-return/
    */
   'small-rules/react-hooks-strict-return'?: Linter.RuleEntry<[]>;
   /**
    * Require async function names to end with Async.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/require-async-suffix/
    */
   'small-rules/require-async-suffix'?: Linter.RuleEntry<SmallRulesRequireAsyncSuffix>;
   /**
    * Require configured classes to be instantiated at module level only.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/require-module-level-instantiation/
    */
   'small-rules/require-module-level-instantiation'?: Linter.RuleEntry<SmallRulesRequireModuleLevelInstantiation>;
   /**
    * Enforce named effect functions for better debuggability. Prevents inline arrow functions in useEffect and similar hooks.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-named-effect-functions/
    */
   'small-rules/require-named-effect-functions'?: Linter.RuleEntry<SmallRulesRequireNamedEffectFunctions>;
   /**
    * Enforces balanced opener/closer function calls across all execution paths
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-paired-calls/
    */
   'small-rules/require-paired-calls'?: Linter.RuleEntry<SmallRulesRequirePairedCalls>;
   /**
    * Require keys on nested React JSX children, fragments, and configured iteration or memoization contexts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-react-component-keys/
    */
   'small-rules/require-react-component-keys'?: Linter.RuleEntry<SmallRulesRequireReactComponentKeys>;
   /**
    * Require displayName on exported memo components and contexts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-react-display-names/
    */
   'small-rules/require-react-display-names'?: Linter.RuleEntry<SmallRulesRequireReactDisplayNames>;
   /**
    * Require braces around switch case bodies selected by line span or statement count.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-switch-case-braces/
    */
   'small-rules/require-switch-case-braces'?: Linter.RuleEntry<SmallRulesRequireSwitchCaseBraces>;
   /**
    * Require 'Error.captureStackTrace' before directly throwing new Error instances in named functions.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-throw-error-capture/
    */
   'small-rules/require-throw-error-capture'?: Linter.RuleEntry<SmallRulesRequireThrowErrorCapture>;
   /**
    * Require the 'u' or 'v' unicode flag on calls named regex().
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-unicode-regex/
    */
   'small-rules/require-unicode-regex'?: Linter.RuleEntry<[]>;
   /**
    * Prevent inline empty object and array defaults in component prop destructuring.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/rerender-memo-with-default-value/
    */
   'small-rules/rerender-memo-with-default-value'?: Linter.RuleEntry<[]>;
   /**
    * Prevent imports that reach into another component's nested modules.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/strict-component-boundaries/
    */
   'small-rules/strict-component-boundaries'?: Linter.RuleEntry<SmallRulesStrictComponentBoundaries>;
   /**
    * Enforce exhaustive and correct dependency specification in React hooks to prevent stale closures and unnecessary re-renders
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/use-exhaustive-dependencies/
    */
   'small-rules/use-exhaustive-dependencies'?: Linter.RuleEntry<SmallRulesUseExhaustiveDependencies>;
   /**
    * Enforce that React hooks are only called at the top level of components or custom hooks, never conditionally or in nested functions
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/use-hook-at-top-level/
    */
   'small-rules/use-hook-at-top-level'?: Linter.RuleEntry<SmallRulesUseHookAtTopLevel>;
   /**
@@ -23387,6 +23490,8 @@ type SmallRulesRequireNamedEffectFunctions = [] | [{
     allowAsync: boolean;
     name: string;
   }[];
+  inlineFunctionDeclarations?: boolean;
+  sloptor?: boolean;
 }];
 // ----- small-rules/require-paired-calls -----
 type SmallRulesRequirePairedCalls = [] | [{

package/dist/index.mjs

@@ -15505,6 +15505,7 @@ const FUNCTIONALLY_TYPE_AWARE_RULES = /* @__PURE__ */ new Set([
 	...typeAwareJsPluginRules,
 	...optionallyTypeAwareRules,
 	"flawless/prefer-read-only-props",
+	"vitest/prefer-describe-function-title",
 	"vitest/valid-title"
 ]);
 /**

package/dist/lint-cli.mjs

@@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region package.json
-var version = "6.0.0-beta.37";
+var version = "6.0.0-beta.39";
 //#endregion
 //#region src/lint-cli/lib/cli/types.ts
 /**

package/dist/oxlint.d.mts

@@ -8380,399 +8380,502 @@ interface RuleOptions {
   'sentinel/prefer-math-min-max'?: Linter.RuleEntry<[]>;
   /**
    * Disallow bracket array type syntax and require Array<T> / ReadonlyArray<T>.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/array-type-generic/
    */
   'small-rules/array-type-generic'?: Linter.RuleEntry<[]>;
   /**
    * Ban specified Roblox Instance classes and configured Instance properties.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/ban-instances/
    */
   'small-rules/ban-instances'?: Linter.RuleEntry<SmallRulesBanInstances>;
   /**
    * Ban React.FC and similar component type annotations. Use explicit function declarations instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/ban-react-fc/
    */
   'small-rules/ban-react-fc'?: Linter.RuleEntry<[]>;
   /**
    * Ban configured TypeScript utility types, defaulting to Omit in favor of Except.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/ban-types/
    */
   'small-rules/ban-types'?: Linter.RuleEntry<SmallRulesBanTypes>;
   /**
    * Enforce consistent spelling of compound words in identifiers.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/consistent-compound-words/
    */
   'small-rules/consistent-compound-words'?: Linter.RuleEntry<SmallRulesConsistentCompoundWords>;
   /**
    * Require a matching enable comment for every `oxlint-disable` or `eslint-disable` block directive.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-disable-enable-pair/
    */
   'small-rules/directive-disable-enable-pair'?: Linter.RuleEntry<SmallRulesDirectiveDisableEnablePair>;
   /**
    * Disallow aggregating `oxlint-enable` or `eslint-enable` comments across multiple disable directives.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-aggregating-enable/
    */
   'small-rules/directive-no-aggregating-enable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow duplicate `oxlint-disable` or `eslint-disable` comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-duplicate-disable/
    */
   'small-rules/directive-no-duplicate-disable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow `oxlint-disable` or `eslint-disable` comments for configured rules.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-restricted-disable/
    */
   'small-rules/directive-no-restricted-disable'?: Linter.RuleEntry<SmallRulesDirectiveNoRestrictedDisable>;
   /**
    * Disallow `oxlint-disable` or `eslint-disable` comments without rule names.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-unlimited-disable/
    */
   'small-rules/directive-no-unlimited-disable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow unused `oxlint-enable` or `eslint-enable` comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-unused-enable/
    */
   'small-rules/directive-no-unused-enable'?: Linter.RuleEntry<[]>;
   /**
    * Disallow block ESLint/Oxlint directive comments.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-no-use/
    */
   'small-rules/directive-no-use'?: Linter.RuleEntry<SmallRulesDirectiveNoUse>;
   /**
    * Require descriptions for `oxlint` and `eslint` disable/enable directives.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/directive-require-description/
    */
   'small-rules/directive-require-description'?: Linter.RuleEntry<SmallRulesDirectiveRequireDescription>;
   /**
    * Enforce Ianitor.Check<T> type annotations on complex TypeScript types
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/enforce-ianitor-check-type/
    */
   'small-rules/enforce-ianitor-check-type'?: Linter.RuleEntry<SmallRulesEnforceIanitorCheckType>;
   /**
    * Prevent usage of variables from outside the scope of isolated functions.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/isolated-functions/
    */
   'small-rules/isolated-functions'?: Linter.RuleEntry<SmallRulesIsolatedFunctions>;
   /**
    * Flags effect dependencies that are not memoized. Unmemoized dependencies can cause unnecessary re-renders or infinite loops.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/memoized-effect-dependencies/
    */
   'small-rules/memoized-effect-dependencies'?: Linter.RuleEntry<SmallRulesMemoizedEffectDependencies>;
   /**
    * Disallow array constructor element forms and enforce roblox-ts-aware constructor patterns.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-constructor-elements/
    */
   'small-rules/no-array-constructor-elements'?: Linter.RuleEntry<SmallRulesNoArrayConstructorElements>;
   /**
    * Disallow new Array<T>() followed by contiguous index assignments; use an array literal instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-constructor-index-assignment/
    */
   'small-rules/no-array-constructor-index-assignment'?: Linter.RuleEntry<[]>;
   /**
    * Disallow array append assignments using array[array.size()] = value (roblox-ts) or array[array.length] = value (standard) and prefer push-based appends.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-array-size-assignment/
    */
   'small-rules/no-array-size-assignment'?: Linter.RuleEntry<SmallRulesNoArraySizeAssignment>;
   /**
    * Disallow asynchronous operations inside class constructors. Constructors return immediately, so async work causes race conditions, unhandled rejections, and incomplete object states.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-async-constructor/
    */
   'small-rules/no-async-constructor'?: Linter.RuleEntry<[]>;
   /**
    * Disallow yielding Roblox API calls in synchronous Planck system execution.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-async-in-system/
    */
   'small-rules/no-async-in-system'?: Linter.RuleEntry<SmallRulesNoAsyncInSystem>;
   /**
    * Disallow effect hooks with many cascading state updates.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-cascading-set-state/
    */
   'small-rules/no-cascading-set-state'?: Linter.RuleEntry<[]>;
   /**
    * Ban new Color3(...) except new Color3() or new Color3(0, 0, 0). Use Color3.fromRGB() instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-color3-constructor/
    */
   'small-rules/no-color3-constructor'?: Linter.RuleEntry<SmallRulesNoColor3Constructor>;
   /**
    * Disallow commented-out code
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-commented-code/
    */
   'small-rules/no-commented-code'?: Linter.RuleEntry<SmallRulesNoCommentedCode>;
   /**
    * Disallow constant conditions, but allow constant loops that include loop exits such as break, return, or configured calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-constant-condition-with-break/
    */
   'small-rules/no-constant-condition-with-break'?: Linter.RuleEntry<SmallRulesNoConstantConditionWithBreak>;
   /**
    * Disallow assignments whose value is never read.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-dead-store/
    */
   'small-rules/no-dead-store'?: Linter.RuleEntry<[]>;
   /**
    * Use throw instead of error().
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-error/
    */
   'small-rules/no-error'?: Linter.RuleEntry<[]>;
   /**
    * Disallow sending Events back to the same player inside an Events.connect callback; use Functions for request/response.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-events-in-events-callback/
    */
   'small-rules/no-events-in-events-callback'?: Linter.RuleEntry<SmallRulesNoEventsInEventsCallback>;
   /**
    * Disallow map(...) directly after filter(...).
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-filter-map-chain/
    */
   'small-rules/no-filter-map-chain'?: Linter.RuleEntry<[]>;
   /**
    * Disallow exact comparisons involving inexact floating-point values.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-floating-point-equality/
    */
   'small-rules/no-floating-point-equality'?: Linter.RuleEntry<[]>;
   /**
    * Report React components whose bodies exceed 300 lines.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-giant-component/
    */
   'small-rules/no-giant-component'?: Linter.RuleEntry<[]>;
   /**
    * Enforce React component size and complexity limits inspired by the 'Refactor God Component' checklist.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-god-components/
    */
   'small-rules/no-god-components'?: Linter.RuleEntry<SmallRulesNoGodComponents>;
   /**
    * Disallow Ianitor validator creation inside function bodies. Hoist to module scope to avoid recreating validators on every call.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-ianitor-in-function-body/
    */
   'small-rules/no-ianitor-in-function-body'?: Linter.RuleEntry<[]>;
   /**
    * Disallow accessing `.success` on Ianitor check results when the full result object is not needed.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-ianitor-success-access/
    */
   'small-rules/no-ianitor-success-access'?: Linter.RuleEntry<[]>;
   /**
    * Disallow pointless identity `.map()` calls that return the parameter unchanged
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-identity-map/
    */
   'small-rules/no-identity-map'?: Linter.RuleEntry<SmallRulesNoIdentityMap>;
   /**
    * Disallow standalone `++` and `--` statements and for-loop update clauses.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-increment-decrement/
    */
   'small-rules/no-increment-decrement'?: Linter.RuleEntry<SmallRulesNoIncrementDecrement>;
   /**
    * Prevent inline properties from being passed to memoized components.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-inline-property-on-memo-component/
    */
   'small-rules/no-inline-property-on-memo-component'?: Linter.RuleEntry<[]>;
   /**
    * Detect instance methods that do not use 'this' and suggest converting them to standalone functions for better performance in roblox-ts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-instance-methods-without-this/
    */
   'small-rules/no-instance-methods-without-this'?: Linter.RuleEntry<SmallRulesNoInstanceMethodsWithoutThis>;
   /**
    * Disallow mutating a loop iterable during iteration.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-loop-iterable-mutation/
    */
   'small-rules/no-loop-iterable-mutation'?: Linter.RuleEntry<[]>;
   /**
    * Disallow spreading static property bags into nativeProperties/*NativeProperties props and onto JSX elements via intermediate objects, because the spread creates a new copied table every render.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-native-properties-spread/
    */
   'small-rules/no-native-properties-spread'?: Linter.RuleEntry<[]>;
   /**
    * Disallow configured constructor calls (default: new Instance) inside React useMemo callbacks.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-new-instance-in-use-memo/
    */
   'small-rules/no-new-instance-in-use-memo'?: Linter.RuleEntry<SmallRulesNoNewInstanceInUseMemo>;
   /**
    * Use Log instead of print().
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-print/
    */
   'small-rules/no-print'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallow recursive function calls to prevent stack overflow.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-recursive/
+   */
   'small-rules/no-recursive'?: Linter.RuleEntry<SmallRulesNoRecursive>;
   /**
    * Disallow redundant uiaspectratioconstraint children inside components that already manage their own aspect ratio internally.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-redundant-aspect-ratio-constraint/
    */
   'small-rules/no-redundant-aspect-ratio-constraint'?: Linter.RuleEntry<[]>;
   /**
    * Disallow non-component functions that return JSX or React elements.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-render-helper-functions/
    */
   'small-rules/no-render-helper-functions'?: Linter.RuleEntry<[]>;
   /**
    * Disallow assignment to restricted object properties.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-restricted-property-assignment/
    */
   'small-rules/no-restricted-property-assignment'?: Linter.RuleEntry<SmallRulesNoRestrictedPropertyAssignment>;
   /**
    * Disallow the .spec.{ts,tsx} file extension for test files. Use .test.{ts,tsx} instead.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/no-spec-file-extension/
    */
   'small-rules/no-spec-file-extension'?: Linter.RuleEntry<[]>;
   /**
    * Require JSX for static React.createElement calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-static-react-create-element/
    */
   'small-rules/no-static-react-create-element'?: Linter.RuleEntry<SmallRulesNoStaticReactCreateElement>;
   /**
    * Disallow map(...) directly on table.create(...) and new Array(...) constructor patterns in roblox-ts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-table-create-map/
    */
   'small-rules/no-table-create-map'?: Linter.RuleEntry<[]>;
   /**
    * Disallow task.wait() and Promise.delay(...).await() calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-task-wait/
    */
   'small-rules/no-task-wait'?: Linter.RuleEntry<[]>;
   /**
    * Disallow assertions that always succeed or compare against freshly created values.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-trivial-assertions/
    */
   'small-rules/no-trivial-assertions'?: Linter.RuleEntry<[]>;
   /**
    * Ban React property names that begin with an underscore in JSX.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-underscore-react-props/
    */
   'small-rules/no-underscore-react-props'?: Linter.RuleEntry<[]>;
   /**
    * Disallow unused imports
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-unused-imports/
    */
   'small-rules/no-unused-imports'?: Linter.RuleEntry<SmallRulesNoUnusedImports>;
   /**
    * Disallow standalone useMemo calls that ignore the memoized value.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-unused-use-memo/
    */
   'small-rules/no-unused-use-memo'?: Linter.RuleEntry<SmallRulesNoUnusedUseMemo>;
   /**
    * Disallow useMemo for expressions that are already trivial to compute.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-use-memo-simple-expression/
    */
   'small-rules/no-use-memo-simple-expression'?: Linter.RuleEntry<[]>;
   /**
    * Disallow using the return value of functions that do not return anything.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-use-of-empty-return-value/
    */
   'small-rules/no-use-of-empty-return-value'?: Linter.RuleEntry<[]>;
   /**
    * Disallow constants that do not add value.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-useless-constants/
    */
   'small-rules/no-useless-constants'?: Linter.RuleEntry<SmallRulesNoUselessConstants>;
   /**
    * Disallow Roblox JSX properties whose values already match the class defaults.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-useless-default/
    */
   'small-rules/no-useless-default'?: Linter.RuleEntry<[]>;
   /**
    * Disallow empty effects, duplicate dependencies, effect chains, log-only effects, derived state, external-store state sync, state initialization, reset effects, parent notifications, parent ref callbacks, and event side effects routed through state.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-effect/
    */
   'small-rules/no-useless-use-effect'?: Linter.RuleEntry<SmallRulesNoUselessUseEffect>;
   /**
    * Disallow useMemo calls that only wrap values static enough to live at module scope.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-memo/
    */
   'small-rules/no-useless-use-memo'?: Linter.RuleEntry<SmallRulesNoUselessUseMemo>;
   /**
    * Disallow useSpring hooks whose config and dependencies are entirely static
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/no-useless-use-spring/
    */
   'small-rules/no-useless-use-spring'?: Linter.RuleEntry<SmallRulesNoUselessUseSpring>;
   /**
    * Disallow spreading a potentially unbounded array into a variadic call, because every element becomes a stack-allocated argument.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/no-variadic-spread/
    */
   'small-rules/no-variadic-spread'?: Linter.RuleEntry<[]>;
   /**
    * Use Log instead of warn().
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/no-warn/
    */
   'small-rules/no-warn'?: Linter.RuleEntry<[]>;
   /**
    * Require all imports to be type-only imports. Benchmarks cannot import non-types because the benchmarker plugin will throw an error.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/only-type-imports/
    */
   'small-rules/only-type-imports'?: Linter.RuleEntry<[]>;
   /**
    * Prefer class properties to assignment of literals in constructors.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-class-properties/
    */
   'small-rules/prefer-class-properties'?: Linter.RuleEntry<SmallRulesPreferClassProperties>;
   /**
    * Disallow inline useReducer action objects that could be module-level constants.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-constant-dispatch/
    */
   'small-rules/prefer-constant-dispatch'?: Linter.RuleEntry<[]>;
   /**
    * Prefer a local ContextStack component over directly nesting multiple context providers.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-context-stack/
    */
   'small-rules/prefer-context-stack'?: Linter.RuleEntry<[]>;
   /**
    * Prefer importing React hooks directly instead of calling them via the React namespace.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-direct-hook-imports/
    */
   'small-rules/prefer-direct-hook-imports'?: Linter.RuleEntry<SmallRulesPreferDirectHookImports>;
   /**
    * Prefer early returns over full-body conditional wrapping.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-early-return/
    */
   'small-rules/prefer-early-return'?: Linter.RuleEntry<SmallRulesPreferEarlyReturn>;
   /**
    * Enforce expect assertion guards in tests and prefer expect.assertions(n) over expect.hasAssertions() when the count is known.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-expect-assertions/
    */
   'small-rules/prefer-expect-assertions'?: Linter.RuleEntry<SmallRulesPreferExpectAssertions>;
   /**
    * Prefer extracting static JSX elements to module-level constants.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-hoisted-jsx-elements/
    */
   'small-rules/prefer-hoisted-jsx-elements'?: Linter.RuleEntry<SmallRulesPreferHoistedJsxElements>;
   /**
    * Prefer extracting inline JSX object props to module-level constants when the entire object is statically hoistable.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-hoisted-jsx-object-properties/
    */
   'small-rules/prefer-hoisted-jsx-object-properties'?: Linter.RuleEntry<[]>;
   /**
-   * Prefer .idiv() for integer division instead of math.floor(x / y).
+   * Prefer .idiv() for integer division instead of math.floor(x / y) or math.floor(x * 0.5).
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-idiv/
    */
   'small-rules/prefer-idiv'?: Linter.RuleEntry<[]>;
   /**
    * Prefer a local Portal component over direct createPortal calls when the project already defines one.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-local-portal-component/
    */
   'small-rules/prefer-local-portal-component'?: Linter.RuleEntry<[]>;
   /**
    * Prefer math.min() and math.max() over simple clamp-like ternaries.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-math-min-max/
    */
   'small-rules/prefer-math-min-max'?: Linter.RuleEntry<[]>;
   /**
    * Prefer Modding.inspect over manually enumerating every enum member in a Record<Enum, true>.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-modding-inspect/
    */
   'small-rules/prefer-modding-inspect'?: Linter.RuleEntry<[]>;
   /**
    * Prefer screaming snake case constants at module scope or the allowed top-level wrapper scope.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/prefer-module-scope-constants/
    */
   'small-rules/prefer-module-scope-constants'?: Linter.RuleEntry<[]>;
   /**
    * Prefer local EqualPadding and DirectionalPadding components over matching <uipadding /> declarations.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-padding-components/
    */
   'small-rules/prefer-padding-components'?: Linter.RuleEntry<[]>;
   /**
    * Enforce PascalCase names for enums and enum members.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prefer-pascal-case-enums/
    */
   'small-rules/prefer-pascal-case-enums'?: Linter.RuleEntry<[]>;
   /**
    * Prefer direct ColorSequence and NumberSequence overloads over identical direct arguments and two-keypoint arrays.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-sequence-overloads/
    */
   'small-rules/prefer-sequence-overloads'?: Linter.RuleEntry<[]>;
   /**
    * Enforce combining multiple world.get() or world.has() calls into a single call for better Jecs performance.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-single-world-query/
    */
   'small-rules/prefer-single-world-query'?: Linter.RuleEntry<[]>;
   /**
    * Prefer singular naming for enums.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prefer-singular-enums/
    */
   'small-rules/prefer-singular-enums'?: Linter.RuleEntry<[]>;
   /**
    * Prefer ternary expressions over complementary JSX && branches.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-ternary-conditional-rendering/
    */
   'small-rules/prefer-ternary-conditional-rendering'?: Linter.RuleEntry<[]>;
   /**
    * Prefer UDim2.fromScale() or UDim2.fromOffset() over new UDim2() when all offsets or all scales are zero.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/prefer-udim2-shorthand/
    */
   'small-rules/prefer-udim2-shorthand'?: Linter.RuleEntry<[]>;
   /**
    * Suggest using useReducer for related state updates instead of multiple useState calls.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/prefer-use-reducer/
    */
   'small-rules/prefer-use-reducer'?: Linter.RuleEntry<[]>;
   /**
    * Prevent abbreviations.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/prevent-abbreviations/
    */
   'small-rules/prevent-abbreviations'?: Linter.RuleEntry<SmallRulesPreventAbbreviations>;
   /**
    * Restrict React hooks to object returns or short tuples.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/react-hooks-strict-return/
    */
   'small-rules/react-hooks-strict-return'?: Linter.RuleEntry<[]>;
   /**
    * Require async function names to end with Async.
+   * @see https://docs.howmanysmall.com/small-rules/rules/naming/require-async-suffix/
    */
   'small-rules/require-async-suffix'?: Linter.RuleEntry<SmallRulesRequireAsyncSuffix>;
   /**
    * Require configured classes to be instantiated at module level only.
+   * @see https://docs.howmanysmall.com/small-rules/rules/roblox/require-module-level-instantiation/
    */
   'small-rules/require-module-level-instantiation'?: Linter.RuleEntry<SmallRulesRequireModuleLevelInstantiation>;
   /**
    * Enforce named effect functions for better debuggability. Prevents inline arrow functions in useEffect and similar hooks.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-named-effect-functions/
    */
   'small-rules/require-named-effect-functions'?: Linter.RuleEntry<SmallRulesRequireNamedEffectFunctions>;
   /**
    * Enforces balanced opener/closer function calls across all execution paths
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-paired-calls/
    */
   'small-rules/require-paired-calls'?: Linter.RuleEntry<SmallRulesRequirePairedCalls>;
   /**
    * Require keys on nested React JSX children, fragments, and configured iteration or memoization contexts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-react-component-keys/
    */
   'small-rules/require-react-component-keys'?: Linter.RuleEntry<SmallRulesRequireReactComponentKeys>;
   /**
    * Require displayName on exported memo components and contexts.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/require-react-display-names/
    */
   'small-rules/require-react-display-names'?: Linter.RuleEntry<SmallRulesRequireReactDisplayNames>;
   /**
    * Require braces around switch case bodies selected by line span or statement count.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-switch-case-braces/
    */
   'small-rules/require-switch-case-braces'?: Linter.RuleEntry<SmallRulesRequireSwitchCaseBraces>;
   /**
    * Require 'Error.captureStackTrace' before directly throwing new Error instances in named functions.
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-throw-error-capture/
    */
   'small-rules/require-throw-error-capture'?: Linter.RuleEntry<SmallRulesRequireThrowErrorCapture>;
   /**
    * Require the 'u' or 'v' unicode flag on calls named regex().
+   * @see https://docs.howmanysmall.com/small-rules/rules/general/require-unicode-regex/
    */
   'small-rules/require-unicode-regex'?: Linter.RuleEntry<[]>;
   /**
    * Prevent inline empty object and array defaults in component prop destructuring.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/rerender-memo-with-default-value/
    */
   'small-rules/rerender-memo-with-default-value'?: Linter.RuleEntry<[]>;
   /**
    * Prevent imports that reach into another component's nested modules.
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/strict-component-boundaries/
    */
   'small-rules/strict-component-boundaries'?: Linter.RuleEntry<SmallRulesStrictComponentBoundaries>;
   /**
    * Enforce exhaustive and correct dependency specification in React hooks to prevent stale closures and unnecessary re-renders
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/use-exhaustive-dependencies/
    */
   'small-rules/use-exhaustive-dependencies'?: Linter.RuleEntry<SmallRulesUseExhaustiveDependencies>;
   /**
    * Enforce that React hooks are only called at the top level of components or custom hooks, never conditionally or in nested functions
+   * @see https://docs.howmanysmall.com/small-rules/rules/react/use-hook-at-top-level/
    */
   'small-rules/use-hook-at-top-level'?: Linter.RuleEntry<SmallRulesUseHookAtTopLevel>;
   /**
@@ -20791,6 +20894,8 @@ type SmallRulesRequireNamedEffectFunctions = [] | [{
     allowAsync: boolean;
     name: string;
   }[];
+  inlineFunctionDeclarations?: boolean;
+  sloptor?: boolean;
 }];
 // ----- small-rules/require-paired-calls -----
 type SmallRulesRequirePairedCalls = [] | [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isentinel/eslint-config",
-  "version": "6.0.0-beta.37",
+  "version": "6.0.0-beta.39",
   "description": "iSentinel's ESLint config",
   "keywords": [
     "eslint-config",
@@ -62,7 +62,7 @@
     "@isentinel/dict-rbxts": "latest",
     "@isentinel/dict-roblox": "latest",
     "@oxlint/plugins": "1.74.0",
-    "@pobammer-ts/small-rules": "2.9.0",
+    "@pobammer-ts/small-rules": "2.14.0",
     "@stylistic/eslint-plugin": "5.10.0",
     "@typescript-eslint/eslint-plugin": "8.65.0",
     "@typescript-eslint/parser": "8.65.0",
@@ -143,7 +143,7 @@
     "typescript": "6.0.3",
     "unplugin-unused": "0.5.7",
     "vitest": "4.1.10",
-    "@isentinel/eslint-config": "6.0.0-beta.37"
+    "@isentinel/eslint-config": "6.0.0-beta.39"
   },
   "peerDependencies": {
     "@vitest/eslint-plugin": "^1.6.4",