@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

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

@@ -2,60 +2,54 @@ 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.
+ * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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
      */
@@ -63,18 +57,18 @@ export interface ITtscLintVitestRules {
     /**
      * 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.
+     * 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.
+     * 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.
+     * 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
      */
@@ -82,28 +76,28 @@ export interface ITtscLintVitestRules {
     /**
      * 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.
+     * 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.
+     * 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.
+     * 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`.
+     * 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.
+     * 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
      */
@@ -111,20 +105,18 @@ export interface ITtscLintVitestRules {
     /**
      * 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.
+     * 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.
+     * 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.
+     * 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
      */
@@ -132,8 +124,8 @@ export interface ITtscLintVitestRules {
     /**
      * Require non-empty static Vitest test and `describe` titles.
      *
-     * Empty or dynamically-built titles produce unreadable failure
-     * output and break filter-by-name flags.
+     * 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
      */

package/linthost/config.go

@@ -140,7 +140,7 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
   out := RuleConfig{}
   for name, sev := range c {
     if sev != SeverityOff {
-      out[normalizeExternalRuleName(name)] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return out
@@ -157,7 +157,7 @@ func normalizeRuleConfigKeys(c RuleConfig) RuleConfig {
   }
   out := RuleConfig{}
   for name, sev := range c {
-    out[normalizeExternalRuleName(name)] = sev
+    out[normalizeBuiltinRuleName(name)] = sev
   }
   return out
 }
@@ -196,7 +196,7 @@ func (r InlineRuleResolver) RuleOptions(name string) json.RawMessage {
   if raw := r.Options[name]; len(raw) > 0 {
     return raw
   }
-  canonical := normalizeExternalRuleName(name)
+  canonical := normalizeBuiltinRuleName(name)
   if raw := r.Options[canonical]; len(raw) > 0 {
     return raw
   }
@@ -231,7 +231,7 @@ func (s *ConfigStore) RuleOptions(name string) json.RawMessage {
   if raw := s.options[name]; len(raw) > 0 {
     return raw
   }
-  canonical := normalizeExternalRuleName(name)
+  canonical := normalizeBuiltinRuleName(name)
   if raw := s.options[canonical]; len(raw) > 0 {
     return raw
   }
@@ -270,7 +270,7 @@ func (s *ConfigStore) ResolveRules(fileName string) ResolvedRuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[normalizeExternalRuleName(name)] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return ResolvedRuleConfig{Rules: out}
@@ -291,7 +291,7 @@ func (s *ConfigStore) ActiveRuleNames() []string {
     }
     for name, sev := range entry.Rules {
       if sev != SeverityOff {
-        active[normalizeExternalRuleName(name)] = sev
+        active[normalizeBuiltinRuleName(name)] = sev
       }
     }
   }
@@ -314,7 +314,7 @@ func (s *ConfigStore) EnabledRuleConfig() RuleConfig {
       if sev == SeverityOff {
         continue
       }
-      canonical := normalizeExternalRuleName(name)
+      canonical := normalizeBuiltinRuleName(name)
       if out[canonical] != SeverityError {
         out[canonical] = sev
       }
@@ -336,7 +336,7 @@ func (s *ConfigStore) Flatten() RuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[normalizeExternalRuleName(name)] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return out
@@ -570,9 +570,10 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
   formatValue, hasFormat := obj["format"]
   if hasRules || hasFormat {
     // Expand the format block (if any) into a rules-shaped map, then
-    // overlay any explicit `rules` entries. `rules`-wins semantics: a
-    // `rules` entry that names a `format/*` rule fully replaces the
-    // entry expanded from the `format` block.
+    // overlay the user's explicit `rules` entries. Formatter settings live
+    // exclusively in the `format` block: any `format/*` key in `rules` is
+    // dropped below (never activates, never overrides the format block), so
+    // the overlay only ever layers lint-rule severities on top.
     var formatRulesRaw map[string]any
     if hasFormat {
       formatMap, ok := formatValue.(map[string]any)
@@ -591,7 +592,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 {
@@ -646,7 +658,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
@@ -675,12 +687,6 @@ func rejectUnknownConfigKeys(value map[string]any, path string) error {
   return nil
 }
 
-// normalizeExternalRuleName strips standard TypeScript-ESLint namespaces while
-// preserving @ttsc/lint's canonical kebab/slash rule IDs.
-func normalizeExternalRuleName(name string) string {
-  return normalizeBuiltinRuleName(name)
-}
-
 // 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.
@@ -767,7 +773,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)
 }
@@ -1053,13 +1059,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 () => {
@@ -1067,8 +1126,8 @@ const { pathToFileURL } = require("node:url");
   let current = mod;
   let allowNamedConfig = true;
   // Match the 8-hop walk used by the TypeScript loader at
-  // ` + "`" + `typeScriptConfigLoaderSource` + "`" + ` so doubly-wrapped CJS/ESM
-  // interop (e.g. ` + "`" + `{default:{default:config}}` + "`" + `) is resolved
+  // `+"`"+`typeScriptConfigLoaderSource`+"`"+` so doubly-wrapped CJS/ESM
+  // interop (e.g. `+"`"+`{default:{default:config}}`+"`"+`) is resolved
   // consistently across .js/.cjs/.mjs and .ts/.cts/.mts loaders.
   for (let i = 0; i < 8; i++) {
     if (current !== null && typeof current === "object" && Object.prototype.hasOwnProperty.call(current, "default")) {
@@ -1096,17 +1155,17 @@ const { pathToFileURL } = require("node:url");
 // toSerializableConfig copies every ITtscLintConfig key onto a plain object so
 // it survives the JSON round trip to the Go sidecar. Every key is copied
 // verbatim — files, ignores, extends, plugins, rules, AND format — so a config
-// whose only key is ` + "`" + `format` + "`" + ` is not silently dropped.
+// 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"
@@ -1114,28 +1173,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
@@ -1194,28 +1232,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
@@ -1303,14 +1320,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
@@ -1731,7 +1748,7 @@ func (c RuleConfig) Severity(name string) Severity {
   if sev, ok := c[name]; ok {
     return sev
   }
-  canonical := normalizeExternalRuleName(name)
+  canonical := normalizeBuiltinRuleName(name)
   if sev, ok := c[canonical]; ok {
     return sev
   }