@ttsc/lint 0.10.1 → 0.11.0-dev.20260517

package/README.md

@@ -18,7 +18,7 @@ Type errors and lint violations appear in one `ttsc` run.
 Given this file:
 
 ```typescript
-// src/lint.ts
+// src/index.ts
 var x: number = 3;
 let y: number = 4;
 const z: string = 5;
@@ -30,22 +30,22 @@ Run `ttsc` with `@ttsc/lint` enabled (see [Setup](#setup)):
 
 ```bash
 $ pnpm ttsc
-src/lint.ts:3:7 - error TS2322: Type 'number' is not assignable to type 'string'.
+src/index.ts:3:7 - error TS2322: Type 'number' is not assignable to type 'string'.
 
 3 const z: string = 5;
         ~
 
-src/lint.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
+src/index.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
 
 2 let y: number = 4;
       ~~~~~~~~~~~~~
 
-src/lint.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
+src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
 
 1 var x: number = 3;
   ~~~~~~~~~~~~~~~~~~
 
-Found 3 errors in the same file, starting at: src/lint.ts:3
+Found 3 errors in the same file, starting at: src/index.ts:3
 ```
 
 Type errors (`TS2322`) and lint violations (`TS17397`, `TS11966`) come out together, in the same `error TSxxxxx` shape.
@@ -54,65 +54,189 @@ CI that already runs `ttsc` blocks on lint with no extra wiring.
 
 ## Setup
 
-Install `ttsc` and TypeScript-Go, then the lint plugin:
+Install the plugin alongside `ttsc` and TypeScript-Go:
 
 ```bash
-npm install -D ttsc @typescript/native-preview
-npm install -D @ttsc/lint
+npm install -D ttsc @typescript/native-preview @ttsc/lint
 ```
 
-Add `lint.config.ts`, or reuse an existing `eslint.config.ts`, next to your project config. If no config file or inline config is found, the compile fails.
+Add a `lint.config.ts` next to your `tsconfig.json`:
 
 ```ts
 // lint.config.ts
-import type { TtscLintConfig } from "@ttsc/lint/config";
+import type { TtscLintConfig } from "@ttsc/lint";
 
 export default {
-  "no-var": "error",
-  "prefer-const": "error",
-  "no-explicit-any": "warning",
-  "no-console": "off",
+  rules: {
+    "no-var": "error",
+    "prefer-const": "error",
+    "no-explicit-any": "warning",
+    "no-console": "off",
+  },
+} satisfies TtscLintConfig;
+```
+
+Run your normal `ttsc` or `ttsx`:
+
+```bash
+npx ttsc
+npx ttsx src/index.ts
+```
+
+Errors fail the command; warnings print without affecting the exit code. Under `ttsx`, errors stop the program before your entrypoint runs.
+
+> Alternate config surfaces — inline `compilerOptions.plugins[].rules`, `extends` paths, and `eslint.config.*` reuse — are described in [Config Files](#config-files) below.
+
+### Fix
+
+```bash
+npx ttsc fix
+```
+
+Applies every autofix the enabled rules offer (lint *and* format), writes the result to disk, then runs the usual no-emit typecheck + lint pass.
+
+Native fixers currently cover:
+
+- `no-var`, single-declaration `prefer-const`, ESLint-safe `eqeqeq`.
+- `no-wrapper-object-types` (`String`/`Number`/`Boolean`/`Symbol`/`BigInt` → primitive; `Object` stays detection-only).
+- `prefer-as-const`, `no-useless-rename`, `object-shorthand`, `no-extra-non-null-assertion`.
+- `no-unnecessary-type-constraint`, `prefer-namespace-keyword`, `no-useless-escape`.
+- `no-import-type-side-effects` (hoists inline `type` modifiers).
+- `await-thenable` (type-aware — drops `await` on non-thenable operands).
+
+If your project uses `eslint.config.*` with an installed ESLint runtime, `ttsc fix` delegates to ESLint's own fixers and reloads the Program before reporting remaining diagnostics.
+
+`ttsc fix` is a one-shot project pass and rejects `--watch`, single-file mode, and `--emit`. Fixes are written to disk before the recheck runs, so source stays modified even when the command exits non-zero on remaining errors.
+
+Recommended flow: run `ttsc fix` locally, commit, then have CI run `ttsc --noEmit` to gate on zero remaining errors.
+
+### Format
+
+```bash
+npx ttsc format
+```
+
+Applies the format-class rules and exits silently. `ttsc fix` does the same plus the lint cascade; pick `format` when you want to reshape source without lint rewrites.
+
+Configure formatting with a Prettier-style `format` block — keys mirror `.prettierrc`:
+
+```ts
+// lint.config.ts
+import type { TtscLintConfig } from "@ttsc/lint";
+
+export default {
+  rules: { "no-var": "error" },
+  format: {
+    printWidth: 100,
+    singleQuote: true,
+    trailingComma: "all",
+    importOrder: ["<THIRD_PARTY_MODULES>", "@api(.*)$", "^[./]"],
+  },
 } satisfies TtscLintConfig;
 ```
 
-Use `compilerOptions.plugins` only when the project needs inline config or an explicit config file path.
+Presence (even empty `format: {}`) enables the always-on rules at Prettier defaults. Setting `importOrder` enables `format/sort-imports`; setting `jsdoc: true` (or an options object) enables `format/jsdoc`. Omit the `format` block entirely to keep every format rule off — same as today's opt-in default.
+
+| Rule | Driven by | Effect |
+| --- | --- | --- |
+| `format/semi` | `semi` | Insert trailing semicolons on ASI-terminated statements. |
+| `format/quotes` | `singleQuote` | Convert quoted strings to the preferred quote style. |
+| `format/trailing-comma` | `trailingComma` | Add trailing commas to multi-line lists. |
+| `format/print-width` | `printWidth`, `tabWidth`, `useTabs`, `endOfLine` | Prettier-style line reflow. Object/array literals, call/new arguments, and named import/export clauses break across lines when their flat form overflows the budget. See [docs/13-format-print-width.md](https://github.com/samchon/ttsc/blob/master/docs/13-format-print-width.md). |
+| `format/sort-imports` | `importOrder*` | Group external/relative imports and alphabetize each group + its specifiers. |
+| `format/jsdoc` | `jsdoc` | Normalize JSDoc blocks toward [prettier-plugin-jsdoc](https://github.com/hosseinmd/prettier-plugin-jsdoc). |
+
+`format.severity` (default `"warning"`) sets the diagnostic level for every format rule in `ttsc check`. `severity: "off"` disables every format rule AND skips its rewrite under `ttsc format` — a one-line CI escape hatch.
+
+To override a single rule's severity or options, drop a sibling `rules` entry — `rules` wins on conflict:
+
+```ts
+export default {
+  format: { semi: true },
+  rules: { "format/semi": "error" },  // bump severity for this one rule only
+} satisfies TtscLintConfig;
+```
+
+Migrating from a `.prettierrc`? See [docs/14-prettier-migration.md](https://github.com/samchon/ttsc/blob/master/docs/14-prettier-migration.md) for the field-by-field cheat sheet and the list of Prettier knobs `@ttsc/lint` does not yet support.
+
+### Config Files
+
+`@ttsc/lint` discovers config from one of three surfaces, in order:
+
+1. **Inline `tsconfig.json` rules** — most local, overrides everything else for that plugin entry.
+
+   ```jsonc
+   {
+     "compilerOptions": {
+       "plugins": [
+         {
+           "transform": "@ttsc/lint",
+           "rules": { "no-var": "error", "prefer-const": "error" },
+         },
+       ],
+     },
+   }
+   ```
+
+2. **`extends` path** — relative path to a standalone config file.
+
+   ```jsonc
+   {
+     "compilerOptions": {
+       "plugins": [
+         { "transform": "@ttsc/lint", "extends": "./lint.config.ts" },
+       ],
+     },
+   }
+   ```
+
+3. **Auto-discovery** — walks upward from the `tsconfig.json` directory and uses the first match:
+
+   - `lint.config.{json,js,mjs,cjs,ts,mts,cts}`
+   - `ttsc-lint.config.{json,js,mjs,cjs,ts,mts,cts}`
+   - `eslint.config.{js,mjs,cjs,ts,mts,cts}` (flat-config compatibility)
+
+`.ts` configs load directly through `ttsx` — no compile step required. `rules` and `extends` cannot be combined on a single plugin entry; pick one or rely on auto-discovery.
+
+### Third-Party Rule Plugins
+
+Third-party packages can contribute Go-implemented lint rules that compile into the same `@ttsc/lint` binary and report through the same diagnostic stream as the built-ins. Two declaration surfaces:
 
 ```jsonc
+// tsconfig.json — inline declaration
 {
   "compilerOptions": {
     "plugins": [
       {
         "transform": "@ttsc/lint",
-        "config": {
-          "no-var": "error",
-          "prefer-const": "error",
-          "no-explicit-any": "warning",
-          "no-console": "off",
-        },
+        "plugins": { "demo": "ttsc-lint-plugin-demo" },
+        "rules": { "demo/no-todo-comment": "error" },
       },
     ],
   },
 }
 ```
 
-Then run your normal `ttsc` or `ttsx`:
-
-```bash
-npx ttsc
-npx ttsx src/index.ts
+```ts
+// lint.config.ts — ESLint flat-config style
+import demoPlugin from "ttsc-lint-plugin-demo";
+import { defineConfig } from "@ttsc/lint";
+
+export default defineConfig([
+  {
+    plugins: { demo: demoPlugin },
+    rules: { "demo/no-todo-comment": "error" },
+  },
+]);
 ```
 
-- Lint errors fail the command.
-- Under `ttsx`, lint errors stop the program before your entrypoint runs.
-- Lint warnings are printed without changing the exit code.
-
-### Config Files
+ttsc copies each declared contributor's Go source into a sub-package of `@ttsc/lint`'s module at build time, so the resulting binary has both built-in and contributor rules registered before `main`. Authoring instructions and the public Go API live in [`docs/10-reference-plugins.md`](https://github.com/samchon/ttsc/blob/master/docs/10-reference-plugins.md#authoring-a-lint-rule-contributor).
 
-By default, `@ttsc/lint` reads config files such as `lint.config.ts` or `eslint.config.ts` next to the selected `tsconfig.json`.
+Contributor rules emit autofixes the same way built-ins do — call `ctx.ReportFix(node, message, edits...)` or `ctx.ReportRangeFix(pos, end, message, edits...)`. The `rule/astutil` package re-exports the byte-range helpers built-ins use (`NodeText`, `KeywordStart`, `FindKeyword`, `TokenRange`). See the [Emitting Autofixes](https://github.com/samchon/ttsc/blob/master/docs/10-reference-plugins.md#emitting-autofixes) section for the full contract and an example.
 
 ## Scope
 
-Diagnostic-only today: no autofix and no bundled recommended preset.
+No bundled recommended preset yet. Rules remain off until you enable them.
 
 ## Rules
 
@@ -129,16 +253,20 @@ Rules are off until you enable them:
 
 Rule severities are `"error"`, `"warning"`, and `"off"`.
 
+Format rules (`format/semi`, `format/quotes`, `format/trailing-comma`, `format/sort-imports`, `format/jsdoc`) are listed separately in the [Format](#format) section above with their per-rule option shapes. The catalog below covers lint-class rules only.
+
 The rule corpus is tested in `tests/test-lint/src/cases/*.ts`, which is the best place to check the exact patterns currently covered. Each rule below links to its tested fixture:
 
 - [`adjacent-overload-signatures`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/adjacent-overload-signatures.ts): keeps overload declarations for the same member adjacent.
 - [`array-type`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/array-type.ts): prefers `T[]` and `readonly T[]` over array helper types.
+- [`await-thenable`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/await-thenable.ts): rejects `await` on a value that is neither a Promise nor a thenable (type-aware).
 - [`ban-ts-comment`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/ban-ts-comment.ts): rejects TypeScript suppression comments such as `@ts-ignore`.
 - [`ban-tslint-comment`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/ban-tslint-comment.ts): rejects obsolete `tslint:` comments.
 - [`consistent-indexed-object-style`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/consistent-indexed-object-style.ts): prefers `Record` for single index-signature object types.
 - [`consistent-type-assertions`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/consistent-type-assertions.ts): prefers `as` type assertions over angle-bracket assertions.
 - [`consistent-type-definitions`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/consistent-type-definitions.ts): prefers interfaces for object-shaped type definitions.
 - [`consistent-type-imports`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/consistent-type-imports/violation.ts): uses `import type` when imported names are type-only.
+- [`default-param-last`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/default-param-last.ts): keeps parameters with default values at the end of the list.
 - [`dot-notation`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/dot-notation.ts): prefers dot property access when a string-literal key is a valid identifier.
 - [`eqeqeq`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/eqeqeq.ts): requires strict equality operators.
 - [`for-direction`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/for-direction.ts): catches loop counters updated in the wrong direction.
@@ -181,6 +309,7 @@ The rule corpus is tested in `tests/test-lint/src/cases/*.ts`, which is the best
 - [`no-extra-non-null-assertion`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-extra-non-null-assertion.ts): rejects repeated non-null assertions.
 - [`no-fallthrough`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-fallthrough.ts): rejects unmarked `switch` fallthrough.
 - [`no-func-assign`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-func-assign.ts): rejects reassignment of function declarations.
+- [`no-import-type-side-effects`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-import-type-side-effects/violation.ts): hoists inline `type` modifiers into a single `import type` declaration.
 - [`no-inferrable-types`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-inferrable-types.ts): rejects type annotations TypeScript can infer.
 - [`no-inner-declarations`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-inner-declarations.ts): rejects function declarations nested in blocks.
 - [`no-irregular-whitespace`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-irregular-whitespace.ts): rejects irregular whitespace.
@@ -191,6 +320,7 @@ The rule corpus is tested in `tests/test-lint/src/cases/*.ts`, which is the best
 - [`no-loss-of-precision`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-loss-of-precision.ts): rejects number literals that lose precision.
 - [`no-misleading-character-class`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-misleading-character-class.ts): rejects misleading regex character classes.
 - [`no-misused-new`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-misused-new.ts): rejects constructor-like signatures in interfaces.
+- [`no-mixed-enums`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-mixed-enums.ts): rejects enums that mix numeric and string members.
 - [`no-multi-assign`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-multi-assign.ts): rejects chained assignments.
 - [`no-multi-str`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-multi-str.ts): rejects multiline string escapes.
 - [`no-namespace`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-namespace.ts): rejects non-ambient namespaces.
@@ -238,6 +368,7 @@ The rule corpus is tested in `tests/test-lint/src/cases/*.ts`, which is the best
 - [`no-useless-computed-key`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-useless-computed-key.ts): rejects unnecessary computed property keys.
 - [`no-useless-concat`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-useless-concat.ts): rejects unnecessary string concatenation.
 - [`no-useless-constructor`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-useless-constructor.ts): rejects empty constructors with no parameters.
+- [`no-useless-escape`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-useless-escape.ts): rejects backslash escapes that have no effect inside strings or regexes.
 - [`no-useless-rename`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-useless-rename.ts): rejects import/export/destructure renames to the same name.
 - [`no-var`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-var.ts): rejects `var`.
 - [`no-with`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/no-with.ts): rejects `with` statements.
@@ -261,3 +392,11 @@ The rule corpus is tested in `tests/test-lint/src/cases/*.ts`, which is the best
 - [`valid-typeof`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/valid-typeof.ts): restricts `typeof` comparisons to valid strings.
 - [`vars-on-top`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/vars-on-top.ts): requires `var` declarations at the top of their scope.
 - [`yoda`](https://github.com/samchon/ttsc/blob/master/tests/test-lint/src/cases/yoda.ts): rejects literal-first comparisons.
+
+## Sponsors
+
+[![Sponsors](https://raw.githubusercontent.com/samchon/sponsor-images/refs/heads/master/public/circle.svg)](https://github.com/sponsors/samchon)
+
+Thanks for your support.
+
+Your [donation](https://github.com/sponsors/samchon) encourages `ttsc` development.

package/lib/defineConfig.d.ts

@@ -0,0 +1,55 @@
+import type { TtscLintConfig } from "./structures/TtscLintConfig";
+import type { TtscLintPlugins } from "./structures/TtscLintPlugins";
+/**
+ * Authoring helper that preserves the literal type of a lint config.
+ *
+ * ESLint's flat-config experience relies on `defineConfig` to capture the
+ * const-narrowed type of the configuration array, which is what makes plugin
+ * rule names autocomplete across entries. `@ttsc/lint` follows the same
+ * pattern: pass your config through this helper and the contributor plugin
+ * objects in `plugins` propagate their `rules` tuples into the rule-name
+ * union.
+ *
+ * ```ts
+ * import { defineConfig } from "@ttsc/lint";
+ * import importPlugin from "@ttsc/lint-plugin-import";
+ *
+ * export default defineConfig([
+ *   {
+ *     plugins: { import: importPlugin },
+ *     rules: {
+ *       "no-var": "error",
+ *       "import/no-cycle": ["error", { maxDepth: 1 }],
+ *     },
+ *   },
+ * ]);
+ * ```
+ *
+ * The function is a pure pass-through at runtime. The generic gymnastics below
+ * gather every `plugins` map across the array of config entries into one
+ * intersected `TtscLintPlugins` shape that gets threaded back into the
+ * `TtscLintConfig<P>` constraint. Without this, `TtscLintConfig`'s default `P =
+ * Record<string, never>` rules out every namespaced rule name and `{
+ * "import/no-cycle": "error" }` would be flagged as a typo.
+ */
+export declare function defineConfig<const T extends TtscLintConfig<GatherPlugins<T>>>(config: T): T;
+/**
+ * Walks the input type to collect every plugin map declared across entries.
+ * Single entries yield the entry's `plugins`; arrays intersect every entry's
+ * `plugins` so each entry's rule-name union remains valid for the whole array.
+ * The intersection (vs. union) is load-bearing — TypeScript's `keyof (A | B)`
+ * collapses to `never`, which would reject every namespaced rule name.
+ *
+ * Plugins declared exclusively inside an `extends` chain are NOT collected:
+ * recursing into `T extends { extends?: infer E } ? GatherPlugins<E> : {}`
+ * blows TypeScript's instantiation budget (`extends` is itself a
+ * `TtscLintConfigEntry` tree). Authors should declare each plugin's `plugins`
+ * map on the outermost entry where its rules are configured. The runtime
+ * resolver still picks up plugins from `extends` entries; only the autocomplete
+ * domain is bounded.
+ */
+type GatherPlugins<T> = T extends {
+    plugins?: infer P;
+} ? P extends TtscLintPlugins ? P : {} : T extends readonly (infer Item)[] ? UnionToIntersection<Item extends unknown ? GatherPlugins<Item> : never> : {};
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export {};

package/lib/defineConfig.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+/**
+ * Authoring helper that preserves the literal type of a lint config.
+ *
+ * ESLint's flat-config experience relies on `defineConfig` to capture the
+ * const-narrowed type of the configuration array, which is what makes plugin
+ * rule names autocomplete across entries. `@ttsc/lint` follows the same
+ * pattern: pass your config through this helper and the contributor plugin
+ * objects in `plugins` propagate their `rules` tuples into the rule-name
+ * union.
+ *
+ * ```ts
+ * import { defineConfig } from "@ttsc/lint";
+ * import importPlugin from "@ttsc/lint-plugin-import";
+ *
+ * export default defineConfig([
+ *   {
+ *     plugins: { import: importPlugin },
+ *     rules: {
+ *       "no-var": "error",
+ *       "import/no-cycle": ["error", { maxDepth: 1 }],
+ *     },
+ *   },
+ * ]);
+ * ```
+ *
+ * The function is a pure pass-through at runtime. The generic gymnastics below
+ * gather every `plugins` map across the array of config entries into one
+ * intersected `TtscLintPlugins` shape that gets threaded back into the
+ * `TtscLintConfig<P>` constraint. Without this, `TtscLintConfig`'s default `P =
+ * Record<string, never>` rules out every namespaced rule name and `{
+ * "import/no-cycle": "error" }` would be flagged as a typo.
+ */
+function defineConfig(config) {
+    return config;
+}
+//# sourceMappingURL=defineConfig.js.map

package/lib/defineConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.js","sourceRoot":"","sources":["../src/defineConfig.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sBACE,MAAS;IAET,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/index.d.ts

@@ -1,9 +1,15 @@
 import type { ITtscLintPluginConfig } from "./structures";
+export * from "./defineConfig";
 export * from "./structures/index";
+type TtscPluginContributor = {
+    name: string;
+    source: string;
+};
 type TtscPluginDescriptor = {
     name: string;
     source: string;
     stage?: "check" | "transform";
+    contributors?: TtscPluginContributor[];
 };
 type TtscPluginFactoryContext<TConfig> = {
     binary: string;
@@ -12,4 +18,22 @@ type TtscPluginFactoryContext<TConfig> = {
     projectRoot: string;
     tsconfig: string;
 };
-export default function createTtscPlugin(_context: TtscPluginFactoryContext<ITtscLintPluginConfig>): TtscPluginDescriptor;
+/**
+ * Plugin descriptor factory for `@ttsc/lint`.
+ *
+ * Two discovery surfaces feed the descriptor's `contributors` field:
+ *
+ * 1. The tsconfig plugin entry's `plugins` map — namespace → npm specifier. Inline
+ *    for projects that prefer to keep everything in `tsconfig.json`.
+ * 2. The companion `lint.config.{ts,cts,mts,js,cjs,mjs,json}` (or
+ *    `eslint.config.*`) file — flat-config-style with an in-memory `plugins: {
+ *    ns: pluginObject }` map. The factory evaluates the config (via ttsx for TS
+ *    / ESM sources, `require` for CommonJS, `JSON.parse` for JSON) and walks
+ *    every entry's `plugins` field.
+ *
+ * Contributions from both sources are merged with the tsconfig entry winning on
+ * namespace collisions, so a project can opt into a hand-curated subset of an
+ * external `lint.config.ts` by overriding specific namespaces in
+ * `tsconfig.json`.
+ */
+export default function createTtscPlugin(context: TtscPluginFactoryContext<ITtscLintPluginConfig>): TtscPluginDescriptor;