@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/lib/structures/rules/ITtscLintUnicornRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintUnicornRules.js.map

package/lib/structures/rules/ITtscLintUnicornRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintUnicornRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintUnicornRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/ITtscLintVitestRules.d.ts

@@ -0,0 +1,141 @@
+import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+/**
+ * Vitest test source rules from `@vitest/eslint-plugin`.
+ *
+ * Vitest reuses much of Jest's testing surface but ships its own
+ * runner and configuration. These rules mirror the ergonomic subset
+ * of `eslint-plugin-jest` adapted for Vitest semantics — focused
+ * tests, identical titles, conditional logic, valid `expect` shape.
+ *
+ * @reference https://github.com/vitest-dev/eslint-plugin-vitest
+ */
+export interface ITtscLintVitestRules {
+    /**
+     * Require every Vitest test body to contain at least one
+     * `expect(...)` call. A test with no assertions still passes,
+     * giving a false-positive signal.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+     */
+    "vitest/expect-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `expect(...)` calls under `if`/`try`/`catch` or other
+     * conditional branches in Vitest tests.
+     *
+     * A branch that never runs turns the assertion into a silent no-op
+     * rather than a failure.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-expect.md
+     */
+    "vitest/no-conditional-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `test(...)`/`it(...)` declarations inside loops or `if`
+     * branches.
+     *
+     * Vitest collects tests at module load, so a conditional
+     * declaration produces a different suite shape than the file
+     * appears to describe.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-tests.md
+     */
+    "vitest/no-conditional-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject `test.skip`, `it.skip`, `describe.skip`, and `.todo`
+     * variants.
+     *
+     * Disabled tests rot in place and quietly drop coverage for the
+     * feature they were meant to pin.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-disabled-tests.md
+     */
+    "vitest/no-disabled-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject `done` callback parameters in Vitest tests and
+     * lifecycle hooks.
+     *
+     * The callback style predates async/await and makes failure
+     * propagation easy to miss; return a Promise or mark the body
+     * `async` instead.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-done-callback.md
+     */
+    "vitest/no-done-callback"?: TtscLintRuleSetting;
+    /**
+     * Reject `test.only`, `it.only`, and `describe.only`.
+     *
+     * A focused suite silently skips the rest of the file, so a stray
+     * `.only` left from debugging hides every other test in CI.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-focused-tests.md
+     */
+    "vitest/no-focused-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject duplicate Vitest test or `describe` titles within the
+     * same suite scope.
+     *
+     * The runner cannot disambiguate two siblings with identical names
+     * in its error output or filter flags.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-identical-title.md
+     */
+    "vitest/no-identical-title"?: TtscLintRuleSetting;
+    /**
+     * Reject `expect(...)` calls outside Vitest tests and hooks.
+     *
+     * Top-level assertions execute at module load before any test
+     * starts, so failures never attach to a named case.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-standalone-expect.md
+     */
+    "vitest/no-standalone-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `return` statements that return non-Promise values from
+     * a Vitest test callback.
+     *
+     * The runner ignores the value and following code is dead, which
+     * usually masks a missing `await` or stray early-exit.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-test-return-statement.md
+     */
+    "vitest/no-test-return-statement"?: TtscLintRuleSetting;
+    /**
+     * Prefer `expect(value).toHaveLength(n)` over asserting on
+     * `value.length` with `toBe`.
+     *
+     * The dedicated matcher reports the actual length on failure
+     * instead of a bare number mismatch.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-to-have-length.md
+     */
+    "vitest/prefer-to-have-length"?: TtscLintRuleSetting;
+    /**
+     * Validate the shape of Vitest `describe` callbacks.
+     *
+     * The callback must be synchronous and take no arguments — the
+     * runner ignores returned Promises and `done`-style parameters at
+     * the describe level.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-describe-callback.md
+     */
+    "vitest/valid-describe-callback"?: TtscLintRuleSetting;
+    /**
+     * Validate `expect(...)` arity and matcher chaining: exactly one
+     * argument, terminated by a matcher call, and async matchers
+     * properly awaited.
+     *
+     * Malformed expects either throw at runtime or pass without
+     * asserting anything.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-expect.md
+     */
+    "vitest/valid-expect"?: TtscLintRuleSetting;
+    /**
+     * Require non-empty static Vitest test and `describe` titles.
+     *
+     * Empty or dynamically-built titles produce unreadable failure
+     * output and break filter-by-name flags.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md
+     */
+    "vitest/valid-title"?: TtscLintRuleSetting;
+}

package/lib/structures/rules/ITtscLintVitestRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintVitestRules.js.map

package/lib/structures/rules/ITtscLintVitestRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintVitestRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintVitestRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/index.d.ts

@@ -0,0 +1,31 @@
+export * from "./ITtscLintBoundariesRuleOptions";
+export * from "./ITtscLintBoundariesRules";
+export * from "./ITtscLintContributorRules";
+export * from "./ITtscLintCoreRules";
+export * from "./ITtscLintCypressRuleOptions";
+export * from "./ITtscLintCypressRules";
+export * from "./ITtscLintFunctionalRuleOptions";
+export * from "./ITtscLintFunctionalRules";
+export * from "./ITtscLintJestRules";
+export * from "./ITtscLintJsdocRules";
+export * from "./ITtscLintJsxA11yRules";
+export * from "./ITtscLintNextjsRules";
+export * from "./ITtscLintPlaywrightRules";
+export * from "./ITtscLintPromiseRules";
+export * from "./ITtscLintReactPerfRuleOptions";
+export * from "./ITtscLintReactPerfRules";
+export * from "./ITtscLintReactRuleOptions";
+export * from "./ITtscLintReactRules";
+export * from "./ITtscLintRegexpRules";
+export * from "./ITtscLintRuleOptionsMap";
+export * from "./ITtscLintRules";
+export * from "./ITtscLintSecurityRules";
+export * from "./ITtscLintSolidRules";
+export * from "./ITtscLintStorybookRuleOptions";
+export * from "./ITtscLintStorybookRules";
+export * from "./ITtscLintTanstackQueryRules";
+export * from "./ITtscLintTestingLibraryRuleOptions";
+export * from "./ITtscLintTestingLibraryRules";
+export * from "./ITtscLintTypeScriptRules";
+export * from "./ITtscLintUnicornRules";
+export * from "./ITtscLintVitestRules";

package/lib/structures/rules/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ITtscLintBoundariesRuleOptions"), exports);
+__exportStar(require("./ITtscLintBoundariesRules"), exports);
+__exportStar(require("./ITtscLintContributorRules"), exports);
+__exportStar(require("./ITtscLintCoreRules"), exports);
+__exportStar(require("./ITtscLintCypressRuleOptions"), exports);
+__exportStar(require("./ITtscLintCypressRules"), exports);
+__exportStar(require("./ITtscLintFunctionalRuleOptions"), exports);
+__exportStar(require("./ITtscLintFunctionalRules"), exports);
+__exportStar(require("./ITtscLintJestRules"), exports);
+__exportStar(require("./ITtscLintJsdocRules"), exports);
+__exportStar(require("./ITtscLintJsxA11yRules"), exports);
+__exportStar(require("./ITtscLintNextjsRules"), exports);
+__exportStar(require("./ITtscLintPlaywrightRules"), exports);
+__exportStar(require("./ITtscLintPromiseRules"), exports);
+__exportStar(require("./ITtscLintReactPerfRuleOptions"), exports);
+__exportStar(require("./ITtscLintReactPerfRules"), exports);
+__exportStar(require("./ITtscLintReactRuleOptions"), exports);
+__exportStar(require("./ITtscLintReactRules"), exports);
+__exportStar(require("./ITtscLintRegexpRules"), exports);
+__exportStar(require("./ITtscLintRuleOptionsMap"), exports);
+__exportStar(require("./ITtscLintRules"), exports);
+__exportStar(require("./ITtscLintSecurityRules"), exports);
+__exportStar(require("./ITtscLintSolidRules"), exports);
+__exportStar(require("./ITtscLintStorybookRuleOptions"), exports);
+__exportStar(require("./ITtscLintStorybookRules"), exports);
+__exportStar(require("./ITtscLintTanstackQueryRules"), exports);
+__exportStar(require("./ITtscLintTestingLibraryRuleOptions"), exports);
+__exportStar(require("./ITtscLintTestingLibraryRules"), exports);
+__exportStar(require("./ITtscLintTypeScriptRules"), exports);
+__exportStar(require("./ITtscLintUnicornRules"), exports);
+__exportStar(require("./ITtscLintVitestRules"), exports);
+//# sourceMappingURL=index.js.map

package/lib/structures/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/rules/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mEAAiD;AACjD,6DAA2C;AAC3C,8DAA4C;AAC5C,uDAAqC;AACrC,gEAA8C;AAC9C,0DAAwC;AACxC,mEAAiD;AACjD,6DAA2C;AAC3C,uDAAqC;AACrC,wDAAsC;AACtC,0DAAwC;AACxC,yDAAuC;AACvC,6DAA2C;AAC3C,0DAAwC;AACxC,kEAAgD;AAChD,4DAA0C;AAC1C,8DAA4C;AAC5C,wDAAsC;AACtC,yDAAuC;AACvC,4DAA0C;AAC1C,mDAAiC;AACjC,2DAAyC;AACzC,wDAAsC;AACtC,kEAAgD;AAChD,4DAA0C;AAC1C,gEAA8C;AAC9C,uEAAqD;AACrD,iEAA+C;AAC/C,6DAA2C;AAC3C,0DAAwC;AACxC,yDAAuC"}

package/linthost/ast_helpers.go

@@ -269,15 +269,40 @@ func stringLiteralText(node *shimast.Node) string {
 }
 
 // walkDescendants visits node and every child below it, depth-first.
+//
+// The naive recursive shape `node.ForEachChild(func(child) bool {
+// walkDescendants(child, visit); return false })` allocates one
+// closure per recursive call (the inner func captures `visit` and
+// the outer function reference), so a subtree of N nodes costs N
+// closure allocations. The struct walker below caches the
+// `ForEachChild` callback as a method value bound once to the
+// walker, dropping that cost to one allocation per `walkDescendants`
+// call regardless of subtree size.
 func walkDescendants(node *shimast.Node, visit func(*shimast.Node)) {
   if node == nil {
     return
   }
-  visit(node)
-  node.ForEachChild(func(child *shimast.Node) bool {
-    walkDescendants(child, visit)
-    return false
-  })
+  w := &descendantsWalker{visit: visit}
+  w.childCB = w.visitChild
+  w.walk(node)
+}
+
+type descendantsWalker struct {
+  visit   func(*shimast.Node)
+  childCB func(*shimast.Node) bool
+}
+
+func (w *descendantsWalker) walk(node *shimast.Node) {
+  if node == nil {
+    return
+  }
+  w.visit(node)
+  node.ForEachChild(w.childCB)
+}
+
+func (w *descendantsWalker) visitChild(child *shimast.Node) bool {
+  w.walk(child)
+  return false
 }
 
 // assignmentTargetNames collects the identifier names written by an

package/linthost/compile.go

@@ -21,6 +21,7 @@ import (
   "os"
   "path/filepath"
   "strings"
+  "time"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -63,6 +64,8 @@ func RunTransform(args []string) int {
   singleThreaded := fs.Bool("singleThreaded", false, "run TypeScript-Go single-threaded")
   checkers := fs.Int("checkers", 0, "type-checker pool size (0 = TypeScript-Go default)")
   tsgoArgsRaw := fs.String("tsgo-args", "", "JSON array of forwarded tsgo CLI flags")
+  _ = fs.Bool("diagnostics", false, "print @ttsc/lint diagnostics timing")
+  _ = fs.Bool("extendedDiagnostics", false, "print @ttsc/lint diagnostics timing")
   if err := fs.Parse(filterKnownFlags(args, LintFlagAllowList)); err != nil {
     return 2
   }
@@ -171,6 +174,7 @@ type subcommandOpts struct {
   noEmit         bool
   quiet          bool
   verbose        bool
+  diagnostics    bool
   outDir         string
   singleThreaded bool
   checkers       int
@@ -190,6 +194,8 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   noEmit := fs.Bool("noEmit", false, "")
   quiet := fs.Bool("quiet", false, "")
   verbose := fs.Bool("verbose", false, "")
+  diagnostics := fs.Bool("diagnostics", false, "")
+  extendedDiagnostics := fs.Bool("extendedDiagnostics", false, "")
   outDir := fs.String("outDir", "", "")
   singleThreaded := fs.Bool("singleThreaded", false, "")
   checkers := fs.Int("checkers", 0, "")
@@ -216,6 +222,7 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
     noEmit:         *noEmit,
     quiet:          *quiet,
     verbose:        *verbose,
+    diagnostics:    *diagnostics || *extendedDiagnostics,
     outDir:         *outDir,
     singleThreaded: *singleThreaded,
     checkers:       *checkers,
@@ -268,11 +275,12 @@ func runProject(opts *subcommandOpts) int {
   }
   defer prog.close()
 
-  astDiags, lintDiags, err := collectDiagnostics(prog, engine)
+  astDiags, lintDiags, diagnosticsTiming, err := collectDiagnosticsTimed(prog, engine)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
+  printLintDiagnosticsTiming(os.Stdout, opts.diagnostics, diagnosticsTiming)
   warnUnknownRules(os.Stderr, engine.UnknownRules())
   if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
@@ -373,9 +381,21 @@ func filterKnownFlags(args []string, known map[string]bool) []string {
 // engine's findings. The renderer takes the two slices and walks them in
 // source order, so we don't need to interleave here.
 func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, error) {
+  astDiags, lintDiags, _, err := collectDiagnosticsTimed(prog, engine)
+  return astDiags, lintDiags, err
+}
+
+type lintDiagnosticsTiming struct {
+  lint time.Duration
+}
+
+func collectDiagnosticsTimed(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, lintDiagnosticsTiming, error) {
+  timing := lintDiagnosticsTiming{}
   astDiags := prog.programDiagnostics()
   files := prog.userSourceFiles()
+  lintStarted := time.Now()
   findings := engine.Run(files, prog.checker)
+  timing.lint = time.Since(lintStarted)
   nativeDiags := make([]*shimdw.LintDiagnostic, 0, len(findings))
   for _, finding := range findings {
     category := shimdw.LintCategoryError
@@ -391,7 +411,18 @@ func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, [
       fmt.Sprintf("[%s] %s", finding.Rule, finding.Message),
     ))
   }
-  return astDiags, nativeDiags, nil
+  return astDiags, nativeDiags, timing, nil
+}
+
+func printLintDiagnosticsTiming(w io.Writer, enabled bool, timing lintDiagnosticsTiming) {
+  if !enabled {
+    return
+  }
+  fmt.Fprintf(w, "@ttsc/lint time: %s\n", formatTimingSeconds(timing.lint))
+}
+
+func formatTimingSeconds(duration time.Duration) string {
+  return fmt.Sprintf("%.3fs", duration.Seconds())
 }
 
 // RuleCode hashes a rule name into a stable, positive int32 so the

package/linthost/config.go

@@ -125,13 +125,13 @@ type RuleResolver interface {
 // ResolveRules implements RuleResolver. A flat RuleConfig has no glob scoping,
 // so every file receives the full map unchanged.
 func (c RuleConfig) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: c}
+  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(c)}
 }
 
 // ActiveRuleNames implements RuleResolver. Returns rule names whose severity
 // is not SeverityOff, sorted for deterministic engine dispatch-table construction.
 func (c RuleConfig) ActiveRuleNames() []string {
-  return sortedRuleNames(c, func(sev Severity) bool { return sev != SeverityOff })
+  return sortedRuleNames(normalizeRuleConfigKeys(c), func(sev Severity) bool { return sev != SeverityOff })
 }
 
 // EnabledRuleConfig implements RuleResolver. Returns a copy containing only the
@@ -140,7 +140,7 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
   out := RuleConfig{}
   for name, sev := range c {
     if sev != SeverityOff {
-      out[name] = sev
+      out[normalizeExternalRuleName(name)] = sev
     }
   }
   return out
@@ -151,6 +151,17 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
 // predate option support.
 func (RuleConfig) RuleOptions(string) json.RawMessage { return nil }
 
+func normalizeRuleConfigKeys(c RuleConfig) RuleConfig {
+  if len(c) == 0 {
+    return c
+  }
+  out := RuleConfig{}
+  for name, sev := range c {
+    out[normalizeExternalRuleName(name)] = sev
+  }
+  return out
+}
+
 // InlineRuleResolver pairs a severity map with an options map. The fields
 // are public so tests can construct one without going through
 // ParseRulesWithOptions.
@@ -162,7 +173,7 @@ type InlineRuleResolver struct {
 // ResolveRules implements RuleResolver. Inline rules have no glob scoping;
 // the full map applies to every file.
 func (r InlineRuleResolver) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: r.Rules}
+  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(r.Rules)}
 }
 
 // ActiveRuleNames implements RuleResolver by delegating to the inner RuleConfig.
@@ -182,7 +193,14 @@ func (r InlineRuleResolver) RuleOptions(name string) json.RawMessage {
   if r.Options == nil {
     return nil
   }
-  return r.Options[name]
+  if raw := r.Options[name]; len(raw) > 0 {
+    return raw
+  }
+  canonical := normalizeExternalRuleName(name)
+  if raw := r.Options[canonical]; len(raw) > 0 {
+    return raw
+  }
+  return nil
 }
 
 // ConfigStore holds the parsed representation of a lint config file. It
@@ -210,7 +228,14 @@ func (s *ConfigStore) RuleOptions(name string) json.RawMessage {
   if s == nil {
     return nil
   }
-  return s.options[name]
+  if raw := s.options[name]; len(raw) > 0 {
+    return raw
+  }
+  canonical := normalizeExternalRuleName(name)
+  if raw := s.options[canonical]; len(raw) > 0 {
+    return raw
+  }
+  return nil
 }
 
 // ConfigEntry is the parsed form of one config file in the extends chain.
@@ -245,7 +270,7 @@ func (s *ConfigStore) ResolveRules(fileName string) ResolvedRuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[name] = sev
+      out[normalizeExternalRuleName(name)] = sev
     }
   }
   return ResolvedRuleConfig{Rules: out}
@@ -266,7 +291,7 @@ func (s *ConfigStore) ActiveRuleNames() []string {
     }
     for name, sev := range entry.Rules {
       if sev != SeverityOff {
-        active[name] = sev
+        active[normalizeExternalRuleName(name)] = sev
       }
     }
   }
@@ -289,8 +314,9 @@ func (s *ConfigStore) EnabledRuleConfig() RuleConfig {
       if sev == SeverityOff {
         continue
       }
-      if out[name] != SeverityError {
-        out[name] = sev
+      canonical := normalizeExternalRuleName(name)
+      if out[canonical] != SeverityError {
+        out[canonical] = sev
       }
     }
   }
@@ -310,7 +336,7 @@ func (s *ConfigStore) Flatten() RuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[name] = sev
+      out[normalizeExternalRuleName(name)] = sev
     }
   }
   return out
@@ -649,12 +675,10 @@ func rejectUnknownConfigKeys(value map[string]any, path string) error {
   return nil
 }
 
-// normalizeExternalRuleName strips the standard typescript-eslint namespace
-// prefixes so that rules like "@typescript-eslint/no-explicit-any" and the
-// bare "no-explicit-any" key both resolve to the same engine-internal name.
+// normalizeExternalRuleName strips standard TypeScript-ESLint namespaces while
+// preserving @ttsc/lint's canonical kebab/slash rule IDs.
 func normalizeExternalRuleName(name string) string {
-  name = strings.TrimPrefix(name, "@typescript-eslint/")
-  return strings.TrimPrefix(name, "typescript-eslint/")
+  return normalizeBuiltinRuleName(name)
 }
 
 // parsePatternList coerces a raw config value to a string slice for use as a
@@ -1704,5 +1728,12 @@ func (c RuleConfig) Severity(name string) Severity {
   if c == nil {
     return SeverityOff
   }
-  return c[name]
+  if sev, ok := c[name]; ok {
+    return sev
+  }
+  canonical := normalizeExternalRuleName(name)
+  if sev, ok := c[canonical]; ok {
+    return sev
+  }
+  return SeverityOff
 }

package/linthost/config_format.go

@@ -47,7 +47,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out := map[string]any{}
 
-  // format/semi
+  // formatSemi
   semiPrefer := "always"
   if v, ok := raw["semi"]; ok {
     b, err := asBool("format.semi", v)
@@ -60,7 +60,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/semi"] = ruleEntry(map[string]any{"prefer": semiPrefer})
 
-  // format/quotes
+  // formatQuotes
   quotesPrefer := "double"
   if v, ok := raw["singleQuote"]; ok {
     b, err := asBool("format.singleQuote", v)
@@ -73,7 +73,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/quotes"] = ruleEntry(map[string]any{"prefer": quotesPrefer})
 
-  // format/trailing-comma
+  // formatTrailingComma
   tcMode := "all"
   if v, ok := raw["trailingComma"]; ok {
     s, err := asString("format.trailingComma", v)
@@ -89,7 +89,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/trailing-comma"] = ruleEntry(map[string]any{"mode": tcMode})
 
-  // format/print-width
+  // formatPrintWidth
   //
   // `trailingComma` is mirrored into the print-width rule's options so
   // the printer's broken-list reflow emits the same trailing-comma
@@ -137,7 +137,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/print-width"] = ruleEntry(pwOpts)
 
-  // format/sort-imports — opt-in by `importOrder`.
+  // formatSortImports — opt-in by `importOrder`.
   if v, ok := raw["importOrder"]; ok {
     siOpts := map[string]any{}
     order, err := asStringSlice("format.importOrder", v)
@@ -145,7 +145,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
       return nil, err
     }
     if len(order) == 0 {
-      return nil, fmt.Errorf("@ttsc/lint: format.importOrder must contain at least one entry; omit the field to keep format/sort-imports off")
+      return nil, fmt.Errorf("@ttsc/lint: format.importOrder must contain at least one entry; omit the field to keep formatSortImports off")
     }
     siOpts["importOrder"] = order
     if x, ok := raw["importOrderSeparation"]; ok {
@@ -172,7 +172,7 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
     out["format/sort-imports"] = ruleEntry(siOpts)
   }
 
-  // format/jsdoc — opt-in by `jsdoc` truthy (boolean or object).
+  // formatJsdoc — opt-in by `jsdoc` truthy (boolean or object).
   if v, ok := raw["jsdoc"]; ok && v != nil {
     jdOpts := map[string]any{}
     enabled := false
@@ -314,7 +314,7 @@ func asStringSlice(field string, v any) ([]string, error) {
 
 // rejectUnknownFormatKeys surfaces typos in top-level format-block
 // keys at the boundary rather than silently ignoring them. The
-// key set mirrors `ITtscLintFormatConfig` exactly.
+// key set mirrors `ITtscLintFormat` exactly.
 func rejectUnknownFormatKeys(raw map[string]any) error {
   allowed := map[string]struct{}{
     "severity":                   {},
@@ -333,7 +333,7 @@ func rejectUnknownFormatKeys(raw map[string]any) error {
   }
   for key := range raw {
     if _, ok := allowed[key]; !ok {
-      return fmt.Errorf("@ttsc/lint: format unknown key %q; see ITtscLintFormatConfig for the allowed surface", key)
+      return fmt.Errorf("@ttsc/lint: format unknown key %q; see ITtscLintFormat for the allowed surface", key)
     }
   }
   return nil