@ttsc/lint 0.18.4 → 0.19.0

package/src/structures/rules/ITtscLintCoreRules.ts

@@ -1,4 +1,26 @@
-import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+import type {
+  TtscLintRuleOptionsSetting,
+  TtscLintRuleSetting,
+} from "../TtscLintRuleSetting";
+import type {
+  ITtscLintCoreDefaultCaseRuleOptions,
+  ITtscLintCoreNoDuplicateImportsRuleOptions,
+  ITtscLintCoreNoElseReturnRuleOptions,
+  ITtscLintCoreNoEmptyFunctionRuleOptions,
+  ITtscLintCoreNoEmptyRuleOptions,
+  ITtscLintCoreNoExtendNativeRuleOptions,
+  ITtscLintCoreNoMixedOperatorsRuleOptions,
+  ITtscLintCoreNoParamReassignRuleOptions,
+  ITtscLintCoreNoPromiseExecutorReturnRuleOptions,
+  ITtscLintCoreNoUnusedExpressionsRuleOptions,
+  ITtscLintCorePreferConstRuleOptions,
+  ITtscLintNoFallthroughRuleOptions,
+  TtscLintCoreGroupedAccessorPairsRuleSetting,
+  TtscLintCoreNoInnerDeclarationsRuleSetting,
+  TtscLintCoreNoRestrictedImportsRuleSetting,
+  TtscLintCoreNoRestrictedSyntaxRuleSetting,
+  TtscLintCoreNoReturnAssignRuleSetting,
+} from "./ITtscLintCoreRuleOptions";
 
 /**
  * Generic ESLint-compatible rules that apply to both JavaScript and TypeScript
@@ -37,7 +59,7 @@ export interface ITtscLintCoreRules {
    *
    * @reference https://eslint.org/docs/latest/rules/default-case
    */
-  "default-case"?: TtscLintRuleSetting;
+  "default-case"?: TtscLintRuleOptionsSetting<ITtscLintCoreDefaultCaseRuleOptions>;
 
   /**
    * Require the `default` clause of a `switch` statement to appear after every
@@ -135,7 +157,7 @@ export interface ITtscLintCoreRules {
    *
    * @reference https://eslint.org/docs/latest/rules/grouped-accessor-pairs
    */
-  "grouped-accessor-pairs"?: TtscLintRuleSetting;
+  "grouped-accessor-pairs"?: TtscLintCoreGroupedAccessorPairsRuleSetting;
 
   /**
    * Require the body of every `for (key in obj)` loop to begin with a guard
@@ -301,10 +323,13 @@ export interface ITtscLintCoreRules {
   "no-case-declarations"?: TtscLintRuleSetting;
 
   /**
-   * Reject reassigning a class binding (`class C {}; C = ...`).
+   * Reject every write to a binding introduced by a class declaration or named
+   * class expression.
    *
-   * The declaration name is effectively final; overwriting it silently leaves
-   * other call sites pointing at the original class.
+   * Binding identity is resolved lexically, so same-spelled parameter, catch,
+   * block, and sibling bindings remain independent. Direct and compound
+   * assignments, updates, destructuring targets, and `for-in`/`for-of` targets
+   * are all covered.
    *
    * @reference https://eslint.org/docs/latest/rules/no-class-assign
    */
@@ -422,8 +447,8 @@ export interface ITtscLintCoreRules {
   "no-dupe-class-members"?: TtscLintRuleSetting;
 
   /**
-   * Reject `if (a) {} else if (a) {}` — the second branch is unreachable
-   * because the first condition already handled it.
+   * Reject an `else if` branch when duplicate or structurally covered
+   * conditions earlier in the same chain make it unreachable.
    *
    * @reference https://eslint.org/docs/latest/rules/no-dupe-else-if
    */
@@ -446,30 +471,33 @@ export interface ITtscLintCoreRules {
   "no-duplicate-case"?: TtscLintRuleSetting;
 
   /**
-   * Reject two import declarations that resolve to the same module specifier.
-   * The runtime sees one module load either way; the duplicated declaration is
-   * purely noise at the head of the file and obscures the dependency graph.
+   * Reject an import declaration whose module specifier already appeared above
+   * when the two declarations could be merged into one legal declaration.
+   * Same-module pairs TypeScript cannot consolidate — named next to namespace
+   * bindings, or a type-only default next to type-only named bindings — are not
+   * duplicates. `allowSeparateTypeImports` additionally keeps clause-level
+   * `import type` declarations apart from value imports, and `includeExports`
+   * folds `export … from` declarations into the same analysis.
    *
    * @reference https://eslint.org/docs/latest/rules/no-duplicate-imports
    */
-  "no-duplicate-imports"?: TtscLintRuleSetting;
+  "no-duplicate-imports"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoDuplicateImportsRuleOptions>;
 
   /**
-   * Reject an `else` block whose preceding `if` branch already terminates
-   * control flow with `return`, `throw`, `break`, or `continue` — flatten the
-   * body into the surrounding scope.
+   * Reject an `else` block whose preceding `if` branch returns on every path;
+   * flatten the body into the surrounding scope.
    *
    * @reference https://eslint.org/docs/latest/rules/no-else-return
    */
-  "no-else-return"?: TtscLintRuleSetting;
+  "no-else-return"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoElseReturnRuleOptions>;
 
   /**
-   * Reject empty blocks (`if (x) {}`, `while (x) {}`, `try {} catch (e) {}`
-   * etc.) that almost always indicate forgotten code.
+   * Reject empty, uncommented blocks and switches. Set `allowEmptyCatch` to
+   * accept an uncommented empty catch clause; its default is `false`.
    *
    * @reference https://eslint.org/docs/latest/rules/no-empty
    */
-  "no-empty"?: TtscLintRuleSetting;
+  "no-empty"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoEmptyRuleOptions>;
 
   /**
    * Reject empty regex character classes (`[]`).
@@ -482,14 +510,13 @@ export interface ITtscLintCoreRules {
   "no-empty-character-class"?: TtscLintRuleSetting;
 
   /**
-   * Reject empty function and method bodies (`function f() {}`, `() => {}`).
-   *
-   * Use `() => undefined` or a leading TODO comment when the empty body is
-   * intentional.
+   * Reject empty, uncommented function bodies. The `allow` option accepts
+   * canonical function, method, accessor, constructor, async, generator,
+   * decorator, and override categories.
    *
    * @reference https://eslint.org/docs/latest/rules/no-empty-function
    */
-  "no-empty-function"?: TtscLintRuleSetting;
+  "no-empty-function"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoEmptyFunctionRuleOptions>;
 
   /**
    * Reject empty named import or export clauses — `import {} from "x"`, `import
@@ -550,17 +577,18 @@ export interface ITtscLintCoreRules {
   "no-ex-assign"?: TtscLintRuleSetting;
 
   /**
-   * Reject assignments to a built-in prototype such as `Array.prototype.foo =
-   * bar`. Only `<Builtin>.prototype.<key> = …` is flagged; assigning to
-   * `Object.foo = …` (a static property) is left alone.
+   * Reject extending a built-in prototype through direct assignment or
+   * `Object.defineProperty` / `Object.defineProperties`. Assigning to a static
+   * property such as `Object.foo` is left alone.
    *
    * @reference https://eslint.org/docs/latest/rules/no-extend-native
    */
-  "no-extend-native"?: TtscLintRuleSetting;
+  "no-extend-native"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoExtendNativeRuleOptions>;
 
   /**
-   * Reject unnecessary `Function.prototype.bind()` calls — for example, binding
-   * without arguments or binding an arrow function (which ignores `this`).
+   * Reject `.bind(thisArg)` on an arrow function or on a regular function whose
+   * own scope never reads `this`. Calls that bind later arguments are preserved
+   * as partial applications.
    *
    * @reference https://eslint.org/docs/latest/rules/no-extra-bind
    */
@@ -575,18 +603,27 @@ export interface ITtscLintCoreRules {
   "no-extra-boolean-cast"?: TtscLintRuleSetting;
 
   /**
-   * Reject `switch` case fall-through unless preceded by an explicit `// falls
-   * through` comment.
+   * Reject `switch` cases that can reach the next `case` / `default` label
+   * without an intentional-fallthrough comment (`// falls through` by
+   * default).
+   *
+   * Reachability follows statement completion: a case whose every path ends in
+   * `break`, `continue`, `return`, or `throw` (composed through blocks,
+   * `if/else`, loops, labeled statements, and `try/catch/finally`) does not
+   * fall through, while a `return` inside a nested function never terminates
+   * the case. Options: {@link ITtscLintNoFallthroughRuleOptions}.
    *
    * @reference https://eslint.org/docs/latest/rules/no-fallthrough
    */
-  "no-fallthrough"?: TtscLintRuleSetting;
+  "no-fallthrough"?: TtscLintRuleOptionsSetting<ITtscLintNoFallthroughRuleOptions>;
 
   /**
-   * Reject reassignment of function declarations (`function f() {}; f = 0;`).
+   * Reject writes to bindings introduced by function declarations and named
+   * function expressions. Lexical binding identity keeps same-spelled shadows
+   * independent across parameters, blocks, catches, and sibling scopes.
    *
-   * The hoisted binding looks final to most readers; overwriting it makes the
-   * original implementation unreachable from other references.
+   * Direct and compound assignment, updates, destructuring, and for-in/of
+   * targets are all modifying references to the function binding.
    *
    * @reference https://eslint.org/docs/latest/rules/no-func-assign
    */
@@ -615,12 +652,13 @@ export interface ITtscLintCoreRules {
   "no-import-assign"?: TtscLintRuleSetting;
 
   /**
-   * Reject `function` and `var` declarations nested in non-function blocks
-   * (loops, `if`, etc.) — they hoist in surprising ways.
+   * Reject function declarations nested in sloppy blocks. The `"both"` mode
+   * also checks `var`; strict ES2015 block-scoped functions are allowed by
+   * default and can be disabled through `blockScopedFunctions`.
    *
    * @reference https://eslint.org/docs/latest/rules/no-inner-declarations
    */
-  "no-inner-declarations"?: TtscLintRuleSetting;
+  "no-inner-declarations"?: TtscLintCoreNoInnerDeclarationsRuleSetting;
 
   /**
    * Reject `this` references outside any function-like, class method, or
@@ -679,10 +717,9 @@ export interface ITtscLintCoreRules {
   "no-lonely-if"?: TtscLintRuleSetting;
 
   /**
-   * Reject function declarations defined inside the body of a loop. Each
-   * iteration of the loop allocates a fresh function whose closure captures the
-   * surrounding `let`/`var` binding — a class of bugs where every captured
-   * function reads the iteration's final value instead of its own.
+   * Reject loop-created closures that capture bindings which can change between
+   * iterations. Constants, per-iteration `let` bindings, and unreferenced
+   * synchronous IIFEs are safe.
    *
    * @reference https://eslint.org/docs/latest/rules/no-loop-func
    */
@@ -719,14 +756,14 @@ export interface ITtscLintCoreRules {
    * The famous case is `a && b || c`: readers expect left-to-right grouping but
    * the parser sees `(a && b) || c` because `&&` binds tighter than `||`.
    *
-   * The conservative baseline only flags the highest-confusion mixes — logical
-   * mixed with a different logical (`&&` next to `||` / `??`), and bitwise
-   * (`&`, `|`, `^`) next to a comparison or logical. Wrapping the inner
-   * sub-expression in parens suppresses the report.
+   * The default groups cover arithmetic, bitwise, comparison, logical, and
+   * relational operators, matching ESLint. A custom `groups` option replaces
+   * that grouping, while `allowSamePrecedence` controls equal-precedence mixes.
+   * Wrapping the inner sub-expression in parens suppresses the report.
    *
    * @reference https://eslint.org/docs/latest/rules/no-mixed-operators
    */
-  "no-mixed-operators"?: TtscLintRuleSetting;
+  "no-mixed-operators"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoMixedOperatorsRuleOptions>;
 
   /**
    * Reject chained assignment such as `a = b = 0`, which obscures intent and
@@ -832,13 +869,14 @@ export interface ITtscLintCoreRules {
   "no-octal-escape"?: TtscLintRuleSetting;
 
   /**
-   * Reject reassigning a function parameter inside the body of the function it
-   * belongs to. The parameter name stops pointing at the caller's argument
-   * after the write. Property mutations (`param.foo = …`) are not flagged.
+   * Reject writes to a function parameter's binding, including through nested
+   * closures and destructuring assignment targets. `props: true` also reports
+   * property writes, with the official exact-name and regular-expression ignore
+   * lists.
    *
    * @reference https://eslint.org/docs/latest/rules/no-param-reassign
    */
-  "no-param-reassign"?: TtscLintRuleSetting;
+  "no-param-reassign"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoParamReassignRuleOptions>;
 
   /**
    * Reject `++` and `--` operators.
@@ -851,12 +889,13 @@ export interface ITtscLintCoreRules {
   "no-plusplus"?: TtscLintRuleSetting;
 
   /**
-   * Reject `return` inside the Promise executor function — the value is
-   * ignored.
+   * Reject values returned by the global Promise constructor's executor. This
+   * covers concise arrows and explicit returns without crossing nested function
+   * boundaries. Set `allowVoid` to accept an explicit unary `void` return.
    *
    * @reference https://eslint.org/docs/latest/rules/no-promise-executor-return
    */
-  "no-promise-executor-return"?: TtscLintRuleSetting;
+  "no-promise-executor-return"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoPromiseExecutorReturnRuleOptions>;
 
   /**
    * Reject access to `obj.__proto__`; use `Object.getPrototypeOf` /
@@ -896,19 +935,23 @@ export interface ITtscLintCoreRules {
   "no-regex-spaces"?: TtscLintRuleSetting;
 
   /**
-   * Reject `import` declarations targeting any module specifier in the project
-   * denylist.
+   * Reject static imports and re-exports selected by exact paths or patterns.
+   * Missing or empty restrictions are a no-op.
    *
    * @reference https://eslint.org/docs/latest/rules/no-restricted-imports
    */
-  "no-restricted-imports"?: TtscLintRuleSetting;
+  "no-restricted-imports"?: TtscLintCoreNoRestrictedImportsRuleSetting;
 
   /**
-   * Reject AST node kinds listed in the project denylist.
+   * Reject syntax matching the configured AST selectors. With no selector
+   * options the rule is silent; it does not impose a built-in denylist.
+   *
+   * Native TypeScript-Go kind names and the documented esquery-compatible
+   * selector forms are supported, including TypeScript-only syntax.
    *
    * @reference https://eslint.org/docs/latest/rules/no-restricted-syntax
    */
-  "no-restricted-syntax"?: TtscLintRuleSetting;
+  "no-restricted-syntax"?: TtscLintCoreNoRestrictedSyntaxRuleSetting;
 
   /**
    * Reject assignment expressions used as the operand of `return` (`return x =
@@ -916,7 +959,7 @@ export interface ITtscLintCoreRules {
    *
    * @reference https://eslint.org/docs/latest/rules/no-return-assign
    */
-  "no-return-assign"?: TtscLintRuleSetting;
+  "no-return-assign"?: TtscLintCoreNoReturnAssignRuleSetting;
 
   /**
    * Reject `javascript:` URLs in string literals — they execute their body as
@@ -1074,12 +1117,21 @@ export interface ITtscLintCoreRules {
   "no-unsafe-optional-chaining"?: TtscLintRuleSetting;
 
   /**
-   * Reject expression statements with no observable effect, like a bare `x;` or
-   * `'use strict' && f();`.
+   * Reject expression statements with no observable effect, like a bare `x;`,
+   * `a === b;`, or a tagged template literal statement.
+   *
+   * Directive prologues — the leading run of string-literal statements at the
+   * top of a script, module, namespace body, or function body — are accepted
+   * whatever their text (`"use strict"`, `"use client"`, …); the same strings
+   * elsewhere are rejected. Productive expressions (calls, `new`, assignments,
+   * updates, `delete`, `void`, `await`, `yield`) are accepted, and JSX is
+   * accepted unless
+   * {@link ITtscLintCoreNoUnusedExpressionsRuleOptions.enforceForJSX} is
+   * enabled.
    *
    * @reference https://eslint.org/docs/latest/rules/no-unused-expressions
    */
-  "no-unused-expressions"?: TtscLintRuleSetting;
+  "no-unused-expressions"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoUnusedExpressionsRuleOptions>;
 
   /**
    * Reject labels that no `break` or `continue` statement references.
@@ -1214,12 +1266,15 @@ export interface ITtscLintCoreRules {
   "prefer-arrow-callback"?: TtscLintRuleSetting;
 
   /**
-   * Require `const` for variables that are never reassigned after declaration.
-   * Autofixable for single-declaration `let`s.
+   * Require `const` for lexical bindings that are never reassigned after their
+   * initial value is established. Declaration-only and destructured bindings
+   * follow ESLint's `ignoreReadBeforeAssign` and `destructuring` options.
+   * Autofixable when one initialized declaration can safely change its shared
+   * `let` keyword.
    *
    * @reference https://eslint.org/docs/latest/rules/prefer-const
    */
-  "prefer-const"?: TtscLintRuleSetting;
+  "prefer-const"?: TtscLintRuleOptionsSetting<ITtscLintCorePreferConstRuleOptions>;
 
   /**
    * Reject single-property and single-index variable declarations (`const a =

package/src/structures/rules/ITtscLintRegexpRules.ts

@@ -102,10 +102,15 @@ export interface ITtscLintRegexpRules {
 
   /**
    * Reject regex flags that the literal does not exercise — `i` on a pattern
-   * without case-variable characters, `m` without `^`/`$`, `s` without `.`, and
-   * similar dead flags on `g`/`y`.
+   * with no case-variable character, `m` on a pattern with no `^`/`$`
+   * assertion.
    *
    * Cleans up flag combos that suggest behavior the pattern can never trigger.
+   * A character is case-variable wherever it sits, so `/[a-z]/i` keeps its flag
+   * (the flag is what extends the class to `A-Z`), and a `^` or `$` inside a
+   * character class is a plain character that does not save `m`. Patterns the
+   * rule cannot settle from the source — a Unicode property escape, a
+   * backreference, a `v`-mode set-notation class — count as using the flag.
    *
    * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-flag.html
    */

package/src/structures/rules/ITtscLintRuleOptionsMap.ts

@@ -1,3 +1,4 @@
+import type { TtscLintRuleOptionsSetting } from "../TtscLintRuleSetting";
 import type {
   ITtscLintBoundariesDependenciesRuleOptions,
   ITtscLintBoundariesElementTypesRuleOptions,
@@ -6,6 +7,20 @@ import type {
   ITtscLintBoundariesNoPrivateRuleOptions,
   ITtscLintBoundariesNoUnknownRuleOptions,
 } from "./ITtscLintBoundariesRuleOptions";
+import type {
+  ITtscLintCoreDefaultCaseRuleOptions,
+  ITtscLintCoreNoDuplicateImportsRuleOptions,
+  ITtscLintCoreNoElseReturnRuleOptions,
+  ITtscLintCoreNoEmptyFunctionRuleOptions,
+  ITtscLintCoreNoEmptyRuleOptions,
+  ITtscLintCoreNoExtendNativeRuleOptions,
+  ITtscLintCoreNoMixedOperatorsRuleOptions,
+  ITtscLintCoreNoParamReassignRuleOptions,
+  ITtscLintCoreNoPromiseExecutorReturnRuleOptions,
+  ITtscLintCoreNoUnusedExpressionsRuleOptions,
+  ITtscLintCorePreferConstRuleOptions,
+  ITtscLintNoFallthroughRuleOptions,
+} from "./ITtscLintCoreRuleOptions";
 import type { ITtscLintCypressUnsafeToChainCommandRuleOptions } from "./ITtscLintCypressRuleOptions";
 import type {
   ITtscLintFunctionalEmptyRuleOptions,
@@ -27,30 +42,68 @@ import type { ITtscLintReactPerfRuleOptions } from "./ITtscLintReactPerfRuleOpti
 import type { ITtscLintReactOnlyExportComponentsRuleOptions } from "./ITtscLintReactRuleOptions";
 import type { ITtscLintStorybookNoUninstalledAddonsRuleOptions } from "./ITtscLintStorybookRuleOptions";
 import type { ITtscLintTestingLibraryConsistentDataTestIdRuleOptions } from "./ITtscLintTestingLibraryRuleOptions";
+import type {
+  ITtscLintTypeScriptBanTsCommentRuleOptions,
+  ITtscLintTypeScriptNoFloatingPromisesRuleOptions,
+  ITtscLintTypeScriptNoMisusedPromisesRuleOptions,
+  ITtscLintTypeScriptNoRestrictedTypesRuleOptions,
+  ITtscLintTypeScriptSwitchExhaustivenessCheckRuleOptions,
+} from "./ITtscLintTypeScriptRuleOptions";
+import type {
+  ITtscLintUnicornBetterRegexRuleOptions,
+  ITtscLintUnicornConsistentFunctionScopingRuleOptions,
+  ITtscLintUnicornFilenameCaseRuleOptions,
+  ITtscLintUnicornImportStyleRuleOptions,
+  ITtscLintUnicornIsolatedFunctionsRuleOptions,
+  ITtscLintUnicornNoTypeofUndefinedRuleOptions,
+  ITtscLintUnicornNoUnnecessaryPolyfillsRuleOptions,
+  ITtscLintUnicornPreferNumberPropertiesRuleOptions,
+  ITtscLintUnicornPreventAbbreviationsRuleOptions,
+  ITtscLintUnicornStringContentRuleOptions,
+  ITtscLintUnicornTemplateIndentRuleOptions,
+  ITtscLintUnicornTextEncodingIdentifierCaseRuleOptions,
+} from "./ITtscLintUnicornRuleOptions";
 
 /**
- * Index from typed rule name to its options object.
+ * Index from typed rule name to its single options-object slot.
  *
- * Built-in rule families with configurable options are listed here. Contributor
- * plugins extend the map by augmenting it from their own package:
+ * Built-in rule families with one object option are listed here. Rules with
+ * canonical positional lists expose dedicated setting types instead.
+ * Contributor plugins extend the map by augmenting it from their own package:
  *
  * ```ts
  * declare module "@ttsc/lint" {
  *   interface ITtscLintRuleOptionsMap {
- *     "demo/no-marker-comment": { marker: string };
+ *     "demo/no-marker-comment": { markers?: readonly string[] };
  *   }
  * }
  * ```
  *
- * After augmentation, `{@link TtscLintRuleOptionsSetting}` tuples and the
- * `defineConfig`-style helpers in plugin packages can type-check the options
- * object against the contributor's declared shape.
+ * {@link TtscLintRuleOptionsOverlay} maps every entry to its strongly typed
+ * severity tuple. {@link ITtscLintRules} intersects that overlay with the
+ * built-in families and the open contributor fallback, so importing a plugin's
+ * augmentation tightens its registered rule while unknown contributor names
+ * retain the backward-compatible `unknown` options slot.
  *
  * `format/*` is **not** listed: formatter behavior is configured through the
  * top-level `format` block ({@link ITtscLintFormat}), not through the `rules`
  * surface.
  */
 export interface ITtscLintRuleOptionsMap {
+  "default-case": ITtscLintCoreDefaultCaseRuleOptions;
+  "unicorn/template-indent": ITtscLintUnicornTemplateIndentRuleOptions;
+  "typescript/no-floating-promises": ITtscLintTypeScriptNoFloatingPromisesRuleOptions;
+  "no-duplicate-imports": ITtscLintCoreNoDuplicateImportsRuleOptions;
+  "no-else-return": ITtscLintCoreNoElseReturnRuleOptions;
+  "no-empty": ITtscLintCoreNoEmptyRuleOptions;
+  "no-empty-function": ITtscLintCoreNoEmptyFunctionRuleOptions;
+  "no-extend-native": ITtscLintCoreNoExtendNativeRuleOptions;
+  "no-mixed-operators": ITtscLintCoreNoMixedOperatorsRuleOptions;
+  "no-param-reassign": ITtscLintCoreNoParamReassignRuleOptions;
+  "no-promise-executor-return": ITtscLintCoreNoPromiseExecutorReturnRuleOptions;
+  "no-unused-expressions": ITtscLintCoreNoUnusedExpressionsRuleOptions;
+  "no-fallthrough": ITtscLintNoFallthroughRuleOptions;
+  "prefer-const": ITtscLintCorePreferConstRuleOptions;
   "testing-library/consistent-data-testid": ITtscLintTestingLibraryConsistentDataTestIdRuleOptions;
   "functional/functional-parameters": ITtscLintFunctionalParametersRuleOptions;
   "functional/immutable-data": ITtscLintFunctionalImmutableDataRuleOptions;
@@ -85,4 +138,32 @@ export interface ITtscLintRuleOptionsMap {
   "react-perf/jsx-no-jsx-as-prop": ITtscLintReactPerfRuleOptions;
   "storybook/no-uninstalled-addons": ITtscLintStorybookNoUninstalledAddonsRuleOptions;
   "react/only-export-components": ITtscLintReactOnlyExportComponentsRuleOptions;
+  "typescript/ban-ts-comment": ITtscLintTypeScriptBanTsCommentRuleOptions;
+  "typescript/no-misused-promises": ITtscLintTypeScriptNoMisusedPromisesRuleOptions;
+  "typescript/no-restricted-types": ITtscLintTypeScriptNoRestrictedTypesRuleOptions;
+  "typescript/switch-exhaustiveness-check": ITtscLintTypeScriptSwitchExhaustivenessCheckRuleOptions;
+  "unicorn/consistent-function-scoping": ITtscLintUnicornConsistentFunctionScopingRuleOptions;
+  "unicorn/better-regex": ITtscLintUnicornBetterRegexRuleOptions;
+  "unicorn/prevent-abbreviations": ITtscLintUnicornPreventAbbreviationsRuleOptions;
+  "unicorn/import-style": ITtscLintUnicornImportStyleRuleOptions;
+  "unicorn/filename-case": ITtscLintUnicornFilenameCaseRuleOptions;
+  "unicorn/string-content": ITtscLintUnicornStringContentRuleOptions;
+  "unicorn/isolated-functions": ITtscLintUnicornIsolatedFunctionsRuleOptions;
+  "unicorn/no-typeof-undefined": ITtscLintUnicornNoTypeofUndefinedRuleOptions;
+  "unicorn/no-unnecessary-polyfills": ITtscLintUnicornNoUnnecessaryPolyfillsRuleOptions;
+  "unicorn/prefer-number-properties": ITtscLintUnicornPreferNumberPropertiesRuleOptions;
+  "unicorn/text-encoding-identifier-case": ITtscLintUnicornTextEncodingIdentifierCaseRuleOptions;
 }
+
+/**
+ * Strongly typed rule settings derived from the augmentable options map.
+ *
+ * This mapped overlay is consumed by {@link ITtscLintRules}; keeping the
+ * derivation here makes module augmentation immediately affect the public
+ * configuration type without a second per-plugin rule-name declaration.
+ */
+export type TtscLintRuleOptionsOverlay = {
+  [TRuleName in keyof ITtscLintRuleOptionsMap]?: TtscLintRuleOptionsSetting<
+    ITtscLintRuleOptionsMap[TRuleName]
+  >;
+};

package/src/structures/rules/ITtscLintRules.ts

@@ -12,6 +12,7 @@ import type { ITtscLintPromiseRules } from "./ITtscLintPromiseRules";
 import type { ITtscLintReactPerfRules } from "./ITtscLintReactPerfRules";
 import type { ITtscLintReactRules } from "./ITtscLintReactRules";
 import type { ITtscLintRegexpRules } from "./ITtscLintRegexpRules";
+import type { TtscLintRuleOptionsOverlay } from "./ITtscLintRuleOptionsMap";
 import type { ITtscLintSecurityRules } from "./ITtscLintSecurityRules";
 import type { ITtscLintSolidRules } from "./ITtscLintSolidRules";
 import type { ITtscLintStorybookRules } from "./ITtscLintStorybookRules";
@@ -51,7 +52,10 @@ import type { ITtscLintVitestRules } from "./ITtscLintVitestRules";
  *   public rules surface.
  * - Any other `"<namespace>/<rule>"` key is accepted via
  *   {@link ITtscLintContributorRules} so plugin-shipped rules compose cleanly
- *   without ambient module augmentation.
+ *   without ambient module augmentation. A plugin can augment
+ *   `ITtscLintRuleOptionsMap`; {@link TtscLintRuleOptionsOverlay} then tightens
+ *   that rule's options while the open fallback remains for unregistered
+ *   contributor names.
  */
 export type ITtscLintRules = ITtscLintCoreRules &
   ITtscLintTypeScriptRules &
@@ -74,4 +78,5 @@ export type ITtscLintRules = ITtscLintCoreRules &
   ITtscLintTestingLibraryRules &
   ITtscLintUnicornRules &
   ITtscLintVitestRules &
-  ITtscLintContributorRules;
+  ITtscLintContributorRules &
+  TtscLintRuleOptionsOverlay;

package/src/structures/rules/ITtscLintSolidRules.ts

@@ -64,15 +64,6 @@ export interface ITtscLintSolidRules {
    */
   "solid/jsx-no-undef"?: TtscLintRuleSetting;
 
-  /**
-   * Scope-marker compatibility rule (mirrors ESLint's `react/jsx-uses-vars`).
-   *
-   * The native engine emits no diagnostics for this id.
-   *
-   * @reference https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-uses-vars.md
-   */
-  "solid/jsx-uses-vars"?: TtscLintRuleSetting;
-
   /**
    * Reject array values passed as Solid event handlers — Solid does not unwrap
    * the array form React supports.