@ttsc/lint 0.13.1 → 0.14.0-dev.20250530.1

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,133 @@
+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/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[normalizeBuiltinRuleName(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[normalizeBuiltinRuleName(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 := normalizeBuiltinRuleName(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 := normalizeBuiltinRuleName(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[normalizeBuiltinRuleName(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[normalizeBuiltinRuleName(name)] = sev
       }
     }
   }
@@ -289,8 +314,9 @@ func (s *ConfigStore) EnabledRuleConfig() RuleConfig {
       if sev == SeverityOff {
         continue
       }
-      if out[name] != SeverityError {
-        out[name] = sev
+      canonical := normalizeBuiltinRuleName(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[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return out
@@ -565,7 +591,18 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
       if !ok {
         return fmt.Errorf("@ttsc/lint: %s.rules must be a rule severity map, got %T", path, rulesValue)
       }
+      // `format/*` rules are configured exclusively through the `format`
+      // block; they are never valid keys in `rules`. Silently drop any that
+      // appear, the same way an unknown rule name is ignored (see
+      // parseExternalRuleMapInto): a config must not carry a formatter
+      // setting in two places, and a stray `format/*` here is simply not the
+      // formatting surface, so it has no effect rather than erroring.
       rulesMap = typedMap
+      for key := range rulesMap {
+        if isFormatRuleName(key) {
+          delete(rulesMap, key)
+        }
+      }
     }
     merged := mergeRuleMaps(formatRulesRaw, rulesMap)
     if len(merged) > 0 {
@@ -620,7 +657,7 @@ func collectExternalRuleMapWithOptions(out RuleConfig, opts RuleOptionsMap, raw
     if err != nil {
       return fmt.Errorf("@ttsc/lint: rule %q: %w", name, err)
     }
-    canonical := normalizeExternalRuleName(name)
+    canonical := normalizeBuiltinRuleName(name)
     out[canonical] = sev
     if opts != nil && len(ruleOpts) > 0 {
       opts[canonical] = ruleOpts
@@ -649,14 +686,6 @@ 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.
-func normalizeExternalRuleName(name string) string {
-  name = strings.TrimPrefix(name, "@typescript-eslint/")
-  return strings.TrimPrefix(name, "typescript-eslint/")
-}
-
 // parsePatternList coerces a raw config value to a string slice for use as a
 // `files` or `ignores` pattern list. Accepts a bare string (single-pattern
 // shorthand) or a string array. Empty patterns are rejected eagerly.
@@ -743,7 +772,7 @@ func LoadConfigResolver(entry *PluginEntry, cwd, tsconfigPath string) (RuleResol
     return nil, err
   }
   if discovered == "" {
-    return nil, fmt.Errorf("@ttsc/lint: no lint.config.* or ttsc-lint.config.* file found (searched upward from %s); create one or set \"configFile\" on the tsconfig plugin entry", cwd)
+    return nil, fmt.Errorf("%w (searched upward from %s); create one or set \"configFile\" on the tsconfig plugin entry", errNoLintConfigFile, cwd)
   }
   return loadConfigResolver(discovered)
 }
@@ -1029,13 +1058,66 @@ func loadJSONConfigFile(location string) (any, error) {
   return out, nil
 }
 
+// serializableConfigKeys is the single source of truth for the ITtscLintConfig
+// keys that survive the JSON round trip from a config-loader subprocess back to
+// the Go sidecar. Both the .js/.cjs/.mjs loader (loadScriptConfigFile) and the
+// .ts/.cts/.mts loader (typeScriptConfigLoaderSource) splice this list into the
+// `toSerializableConfig` key whitelist of their generated scripts, so the set
+// of copied keys is defined here once rather than duplicated per loader.
+var serializableConfigKeys = []string{"files", "ignores", "extends", "plugins", "rules", "format"}
+
+// serializableConfigKeysLiteral renders serializableConfigKeys as a
+// JS/TS array literal (e.g. `"files", "ignores", ...`) for splicing into the
+// generated loader scripts' `toSerializableConfig` whitelist.
+func serializableConfigKeysLiteral() string {
+  quoted := make([]string, len(serializableConfigKeys))
+  for i, key := range serializableConfigKeys {
+    quoted[i] = fmt.Sprintf("%q", key)
+  }
+  return strings.Join(quoted, ", ")
+}
+
+// runConfigLoaderCommand runs a prepared config-loader subprocess (`cmd`),
+// then turns its result into a parsed config object. It owns the shared tail
+// of both subprocess-backed loaders: capturing stdout, distinguishing a
+// timeout from a process error (extracting the subprocess stderr when present),
+// JSON-parsing the output, and rejecting a non-object result. `ctx` is the
+// timeout context the caller bound `cmd` to; `location` is the config file path
+// for error messages; `label` is the human-readable subject (e.g. "config
+// file" or "TypeScript config file") spliced into the load/parse error
+// prefixes so each loader keeps its own wording.
+func runConfigLoaderCommand(ctx context.Context, cmd *exec.Cmd, location, label string) (any, error) {
+  output, err := cmd.Output()
+  if err != nil {
+    if ctx.Err() == context.DeadlineExceeded {
+      return nil, fmt.Errorf("@ttsc/lint: load %s %s: timed out after %s", label, location, configLoaderTimeout)
+    }
+    stderr := ""
+    if exit, ok := err.(*exec.ExitError); ok {
+      stderr = strings.TrimSpace(string(exit.Stderr))
+    }
+    if stderr != "" {
+      return nil, fmt.Errorf("@ttsc/lint: load %s %s: %s", label, location, stderr)
+    }
+    return nil, fmt.Errorf("@ttsc/lint: load %s %s: %w", label, location, err)
+  }
+  var out any
+  if err := json.Unmarshal(output, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: parse %s %s output: %w", label, location, err)
+  }
+  if !isConfigObject(out) {
+    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
+  }
+  return out, nil
+}
+
 // loadScriptConfigFile evaluates a .js/.cjs/.mjs config file by running a
 // Node subprocess that dynamic-imports the file, resolves the exported config
 // through the same 8-hop default/config unwrap used by the TS loader, and
 // serializes the result as JSON to stdout. The subprocess has a
 // configLoaderTimeout deadline to prevent user code from hanging indefinitely.
 func loadScriptConfigFile(location string) (any, error) {
-  const script = `
+  script := fmt.Sprintf(`
 const { pathToFileURL } = require("node:url");
 
 (async () => {
@@ -1075,14 +1157,14 @@ const { pathToFileURL } = require("node:url");
 // whose only key is ` + "`" + `format` + "`" + ` is not silently dropped.
 function toSerializableConfig(value) {
   const out = {};
-  for (const key of ["files", "ignores", "extends", "plugins", "rules", "format"]) {
+  for (const key of [%s]) {
     if (Object.prototype.hasOwnProperty.call(value, key)) {
       out[key] = value[key];
     }
   }
   return out;
 }
-`
+`, serializableConfigKeysLiteral())
   node := os.Getenv("TTSC_NODE_BINARY")
   if node == "" {
     node = "node"
@@ -1090,28 +1172,7 @@ function toSerializableConfig(value) {
   ctx, cancel := context.WithTimeout(context.Background(), configLoaderTimeout)
   defer cancel()
   cmd := exec.CommandContext(ctx, node, "-e", script, location)
-  output, err := cmd.Output()
-  if err != nil {
-    if ctx.Err() == context.DeadlineExceeded {
-      return nil, fmt.Errorf("@ttsc/lint: load config file %s: timed out after %s", location, configLoaderTimeout)
-    }
-    stderr := ""
-    if exit, ok := err.(*exec.ExitError); ok {
-      stderr = strings.TrimSpace(string(exit.Stderr))
-    }
-    if stderr != "" {
-      return nil, fmt.Errorf("@ttsc/lint: load config file %s: %s", location, stderr)
-    }
-    return nil, fmt.Errorf("@ttsc/lint: load config file %s: %w", location, err)
-  }
-  var out any
-  if err := json.Unmarshal(output, &out); err != nil {
-    return nil, fmt.Errorf("@ttsc/lint: parse config file %s output: %w", location, err)
-  }
-  if !isConfigObject(out) {
-    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
-  }
-  return out, nil
+  return runConfigLoaderCommand(ctx, cmd, location, "config file")
 }
 
 // loadTypeScriptConfigFile evaluates a .ts/.cts/.mts config file by writing
@@ -1170,28 +1231,7 @@ func loadTypeScriptConfigFile(location string) (any, error) {
   defer cancel()
   cmd := ttsxCommandContext(ctx, args...)
   cmd.Env = nodeConfigLoaderEnv(location)
-  output, err := cmd.Output()
-  if err != nil {
-    if ctx.Err() == context.DeadlineExceeded {
-      return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: timed out after %s", location, configLoaderTimeout)
-    }
-    stderr := ""
-    if exit, ok := err.(*exec.ExitError); ok {
-      stderr = strings.TrimSpace(string(exit.Stderr))
-    }
-    if stderr != "" {
-      return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: %s", location, stderr)
-    }
-    return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: %w", location, err)
-  }
-  var out any
-  if err := json.Unmarshal(output, &out); err != nil {
-    return nil, fmt.Errorf("@ttsc/lint: parse TypeScript config file %s output: %w", location, err)
-  }
-  if !isConfigObject(out) {
-    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
-  }
-  return out, nil
+  return runConfigLoaderCommand(ctx, cmd, location, "TypeScript config file")
 }
 
 // isConfigObject reports whether `value` is a top-level config object. A lint
@@ -1279,14 +1319,14 @@ function hasOwn(value: Record<string, unknown>, key: string): boolean {
 // whose only key is "format" is not silently dropped.
 function toSerializableConfig(value: Record<string, unknown>): Record<string, unknown> {
   const out: Record<string, unknown> = {};
-  for (const key of ["files", "ignores", "extends", "plugins", "rules", "format"]) {
+  for (const key of [%s]) {
     if (hasOwn(value, key)) {
       out[key] = value[key];
     }
   }
   return out;
 }
-`, importLiteral)
+`, importLiteral, serializableConfigKeysLiteral())
 }
 
 // typeScriptConfigLoaderTsconfig generates the JSON content of the ephemeral
@@ -1704,5 +1744,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 := normalizeBuiltinRuleName(name)
+  if sev, ok := c[canonical]; ok {
+    return sev
+  }
+  return SeverityOff
 }