@ttsc/lint 0.30.3 → 0.31.0

package/linthost/load_rule_config_rejects_extends_cycle_between_two_configs_test.go

@@ -0,0 +1,71 @@
+package linthost
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoadRuleConfigRejectsExtendsCycleBetweenTwoConfigs verifies that two
+// config files that `extends` each other fail fast instead of recursing
+// without bound.
+//
+// `collectConfigObject` resolves `extends` recursively through the config loader;
+// executable configs can reuse cached evaluation. The lineage guard reports
+// `a -> b -> a` as a cycle before the return hop loads `a.config.json` again,
+// rather than eventually rejecting it as an overly deep chain. This case
+// asserts the cycle diagnostic and filenames, not read or process counts.
+//
+//  1. Write `a.config.json` and `b.config.json` that each `extends` the other.
+//  2. Call LoadRuleConfig with `configFile: "./a.config.json"`.
+//  3. Assert a non-nil error that says `extends cycle detected` and names both
+//     files.
+//  4. Repeat the original discovery-root cycle and reject its return edge.
+//  5. Remove that return edge and accept the adjacent acyclic chain.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig rejects an explicit a-to-b-to-a cycle and LoadConfigResolver rejects the migrated discovered lint.config.json-to-b-to-lint cycle before any rule or native host executes.
+// @evidence contracts/testing.md#independent-expectations A finite config-extends lineage must not revisit a file; independently authored two-file graphs and the literal cycle diagnostic establish rejection, with both filenames required for the explicit-path case.
+// @evidence contracts/testing.md#distinguishing-cases Preserves the explicit two-node cycle and adds the discovery-root cycle without rules; replacing the return edge with an empty object proves the same two-file chain becomes valid. Self-reference and depth-limit cases remain separate tests.
+// @evidence contracts/testing.md#execution-ownership TestLoadRuleConfigRejectsExtendsCycleBetweenTwoConfigs owns both direct Go resolver routes in the selected unit process, using JSON fixture files without script evaluation, native compilation or a child host.
+func TestLoadRuleConfigRejectsExtendsCycleBetweenTwoConfigs(t *testing.T) {
+  dir := t.TempDir()
+  writeFile(t, filepath.Join(dir, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(dir, "a.config.json"), `{
+    "extends": "./b.config.json",
+    "rules": { "no-var": "error" }
+  }`)
+  writeFile(t, filepath.Join(dir, "b.config.json"), `{
+    "extends": "./a.config.json",
+    "rules": { "eqeqeq": "error" }
+  }`)
+
+  _, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{
+      "configFile": "./a.config.json",
+    },
+  }, dir, "tsconfig.json")
+  if err == nil {
+    t.Fatal("expected a cyclic extends chain to fail")
+  }
+  message := err.Error()
+  if !strings.Contains(message, "extends cycle detected") {
+    t.Fatalf("error should name the cycle, got %v", err)
+  }
+  if !strings.Contains(message, "a.config.json") || !strings.Contains(message, "b.config.json") {
+    t.Fatalf("error should name both files in the cycle, got %v", err)
+  }
+
+  discoveredRoot := t.TempDir()
+  writeFile(t, filepath.Join(discoveredRoot, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(discoveredRoot, "lint.config.json"), `{"extends":"./b.config.json"}`)
+  base := filepath.Join(discoveredRoot, "b.config.json")
+  writeFile(t, base, `{"extends":"./lint.config.json"}`)
+  _, discoveredErr := LoadConfigResolver(&PluginEntry{}, discoveredRoot, "tsconfig.json")
+  if discoveredErr == nil || !strings.Contains(discoveredErr.Error(), "extends cycle detected") {
+    t.Fatalf("discovered cycle error = %v, want extends cycle detected", discoveredErr)
+  }
+  writeFile(t, base, "{}")
+  if _, err := LoadConfigResolver(&PluginEntry{}, discoveredRoot, "tsconfig.json"); err != nil {
+    t.Fatalf("acyclic discovered chain rejected: %v", err)
+  }
+}

package/linthost/load_rule_config_rejects_missing_discovered_config_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoadRuleConfigRejectsMissingDiscoveredConfig verifies that an empty Config map with no
+// lint config file present produces a clear error rather than a silent empty config.
+//
+// An empty Config map triggers auto-discovery; if no lint.config.* or ttsc-lint.config.* file
+// exists, the engine would run with zero rules and silently pass every project. The error must
+// point the user at creating a config file or setting "configFile".
+//
+// 1. Write only a tsconfig.json in the temp dir (no lint config file).
+// 2. Call LoadRuleConfig with an empty Config map.
+// 3. Assert an error is returned mentioning both "lint.config" and "configFile".
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig rejects missing automatic discovery and explains both the lint.config naming route and explicit configFile alternative.
+// @evidence contracts/testing.md#independent-expectations A missing required lint config must not silently run an empty rule set; the literal remediation terms establish user-facing diagnostic meaning.
+// @evidence contracts/testing.md#distinguishing-cases Owns a tsconfig-only tree with no candidate; a co-located recognized config is the positive counterpart.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go entry owns the case described above. A temporary tsconfig-only tree reaches LoadRuleConfig directly in-process; the error and literal remediation vocabulary establish missing-config handling without any child evaluator.
+func TestLoadRuleConfigRejectsMissingDiscoveredConfig(t *testing.T) {
+  dir := t.TempDir()
+  writeFile(t, filepath.Join(dir, "tsconfig.json"), "{}")
+
+  _, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{},
+  }, dir, "tsconfig.json")
+  if err == nil {
+    t.Fatal("expected missing lint config to fail")
+  }
+  if !strings.Contains(err.Error(), "lint.config") || !strings.Contains(err.Error(), "configFile") {
+    t.Fatalf("error should explain required config discovery, got %v", err)
+  }
+}

package/linthost/load_rule_config_rejects_overly_deep_extends_chain_test.go

@@ -0,0 +1,53 @@
+package linthost
+
+import (
+  "fmt"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoadRuleConfigRejectsOverlyDeepExtendsChain verifies that a linear,
+// non-cyclic `extends` chain longer than extendsDepthLimit fails fast.
+//
+// Cycle detection compares cleaned paths within the current lineage. The
+// separate depth cap also bounds a strictly forward chain of distinct configs.
+// This JSON-only case observes its diagnostic, not executable-loader process
+// counts, path-alias identity, or a global bound on every config branch.
+//
+//  1. Write `cfg0.config.json` ... `cfgN.config.json` where each file `extends`
+//     the next and the chain length exceeds extendsDepthLimit.
+//  2. Call LoadRuleConfig with `configFile: "./cfg0.config.json"`.
+//  3. Assert a non-nil error that mentions the depth limit.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig rejects a non-cyclic authored config lineage longer than its supported depth budget with a depth-limit diagnostic.
+// @evidence contracts/testing.md#independent-expectations The bounded extends contract caps recursive loading independently of cycle presence; an explicitly constructed strictly forward chain supplies the over-limit premise.
+// @evidence contracts/testing.md#distinguishing-cases Owns a depth-limit-plus-eight acyclic lineage; short linear inheritance and self/two-file cycles are distinct tests. The fixture uses the named limit to remain an over-limit case rather than certify a particular numeric policy.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go entry owns the case described above. The temporary forward JSON lineage reaches LoadRuleConfig directly in the shared Go process; recursive loading and its depth error require no script evaluator or native host build.
+func TestLoadRuleConfigRejectsOverlyDeepExtendsChain(t *testing.T) {
+  dir := t.TempDir()
+  writeFile(t, filepath.Join(dir, "tsconfig.json"), "{}")
+
+  const chainLength = extendsDepthLimit + 8
+  for i := 0; i < chainLength; i++ {
+    name := fmt.Sprintf("cfg%d.config.json", i)
+    if i == chainLength-1 {
+      writeFile(t, filepath.Join(dir, name), `{ "rules": { "no-var": "error" } }`)
+      continue
+    }
+    writeFile(t, filepath.Join(dir, name), fmt.Sprintf(
+      `{ "extends": "./cfg%d.config.json", "rules": { "no-var": "error" } }`, i+1))
+  }
+
+  _, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{
+      "configFile": "./cfg0.config.json",
+    },
+  }, dir, "tsconfig.json")
+  if err == nil {
+    t.Fatal("expected an over-deep extends chain to fail")
+  }
+  if !strings.Contains(err.Error(), "depth limit") {
+    t.Fatalf("error should mention the depth limit, got %v", err)
+  }
+}

package/linthost/load_rule_config_rejects_self_referential_extends_test.go

@@ -0,0 +1,49 @@
+package linthost
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoadRuleConfigRejectsSelfReferentialExtends verifies that a config file
+// whose `extends` points at itself fails fast.
+//
+// Seeding the lineage with the root config's cleaned absolute path lets the
+// guard reject a self-reference on its first hop, before loading that root
+// again. This case asserts the cycle and filename diagnostic; it does not
+// count reads or distinguish first-hop detection from a later cycle error.
+//
+//  1. Write a single `a.config.json` whose `extends` names `a.config.json`.
+//  2. Call LoadRuleConfig with `configFile: "./a.config.json"`.
+//  3. Assert a non-nil error that says `extends cycle detected` and names the
+//     file.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig rejects a root config extending itself and names both the cycle and self-referential a.config.json.
+// @evidence contracts/testing.md#independent-expectations A config lineage cannot revisit its root; independently authored self-reference and the literal cycle and filename fragments distinguish the required diagnostic.
+// @evidence contracts/testing.md#distinguishing-cases Owns the first-hop self-cycle boundary; two-file cycles, valid linear chains, and non-cyclic excessive depth remain independent cases.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go entry owns the case described above. A temporary JSON root extending itself reaches LoadRuleConfig directly in-process; cycle and filename errors observe owning recursion without a child host or native contributor.
+func TestLoadRuleConfigRejectsSelfReferentialExtends(t *testing.T) {
+  dir := t.TempDir()
+  writeFile(t, filepath.Join(dir, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(dir, "a.config.json"), `{
+    "extends": "./a.config.json",
+    "rules": { "no-var": "error" }
+  }`)
+
+  _, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{
+      "configFile": "./a.config.json",
+    },
+  }, dir, "tsconfig.json")
+  if err == nil {
+    t.Fatal("expected a self-referential extends to fail")
+  }
+  message := err.Error()
+  if !strings.Contains(message, "extends cycle detected") {
+    t.Fatalf("error should name the cycle, got %v", err)
+  }
+  if !strings.Contains(message, "a.config.json") {
+    t.Fatalf("error should name the self-referential file, got %v", err)
+  }
+}

package/linthost/load_rule_config_resolves_configfile_relative_to_plugin_config_dir_env_test.go

@@ -0,0 +1,46 @@
+package linthost
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestLoadRuleConfigResolvesConfigFileRelativeToPluginConfigDirEnv verifies
+// that a relative "configFile" plugin-entry path resolves against
+// TTSC_PLUGIN_CONFIG_DIR when the channel is set.
+//
+// Locks resolveConfigFilePath through the explicit anchor: when a build
+// integration compiles through a generated wrapper tsconfig in a temp
+// directory, a relative configFile would otherwise dangle against the temp
+// dir and fail with a not-found error.
+//
+//  1. Seed a project dir with custom.lint.json and a wrapper dir with only a
+//     tsconfig.json.
+//  2. Set TTSC_PLUGIN_CONFIG_DIR to the project and call LoadRuleConfig with
+//     configFile "custom.lint.json" and the wrapper tsconfig.
+//  3. Assert the project-relative file is loaded.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig loads no-var/error from the project custom.lint.json when a relative configFile is paired with TTSC_PLUGIN_CONFIG_DIR and an outside wrapper.
+// @evidence contracts/testing.md#independent-expectations The explicit config-directory channel anchors relative plugin config paths; the authored project-only custom file and severity map independently establish the expected resolution.
+// @evidence contracts/testing.md#distinguishing-cases Owns relative explicit config with separate wrapper and channel-set origin; ordinary tsconfig-relative resolution and channel-set discovery are separate entries.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go entry owns the case described above. A project-only custom JSON file and outside wrapper reach LoadRuleConfig under a scoped config-directory environment in-process; resolved severity observes anchoring and testing restores the environment.
+func TestLoadRuleConfigResolvesConfigFileRelativeToPluginConfigDirEnv(t *testing.T) {
+  dir := t.TempDir()
+  wrapperDir := t.TempDir()
+  wrapper := filepath.Join(wrapperDir, "tsconfig.json")
+  writeFile(t, wrapper, "{}")
+  writeFile(t, filepath.Join(dir, "custom.lint.json"), `{
+    "rules": { "no-var": "error" }
+  }`)
+
+  t.Setenv("TTSC_PLUGIN_CONFIG_DIR", dir)
+  cfg, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{"configFile": "custom.lint.json"},
+  }, dir, wrapper)
+  if err != nil {
+    t.Fatalf("LoadRuleConfig: %v", err)
+  }
+  if cfg.Severity("no-var") != SeverityError {
+    t.Fatalf("no-var: want error from the project-relative configFile, got %v", cfg.Severity("no-var"))
+  }
+}

package/linthost/load_rule_config_resolves_linear_extends_chain_test.go

@@ -0,0 +1,81 @@
+package linthost
+
+import (
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestLoadRuleConfigResolvesLinearExtendsChain verifies that a valid, acyclic
+// `extends` chain still merges rules in the documented order.
+//
+// The cycle/depth guard must not regress legitimate inheritance: the
+// extends-target's entries are appended first so the extending file's own
+// rules win on collision. This pins that a base file's rules are inherited and
+// that a local override outranks the inherited severity.
+//
+//  1. Write a base `b.config.json` (`noVar: warning`, `eqeqeq: error`).
+//  2. Write `a.config.json` that `extends` it and re-declares `noVar: error`.
+//  3. Call LoadRuleConfig and assert `eqeqeq` is inherited and the local
+//     `noVar: error` override wins over the base `warning`.
+//  4. Discover the original base-only config and run its exact var/export source through Engine.
+//  5. Require one inherited no-var/error finding and none for the adjacent const source.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadRuleConfig inherits eqeqeq/error from b.config.json while local no-var/error overrides the base no-var/warning; the original discovered base-only fixture produces exactly one ordinary no-var/error finding for var/export, rejecting recovered rule-execution errors, and no finding for its const control.
+// @evidence contracts/testing.md#independent-expectations Extends entries fold base-first and child declarations win severity collisions; independently authored base and child maps supply exact expected inherited and overridden values.
+// @evidence contracts/testing.md#distinguishing-cases Owns successful two-file inheritance with one collision and one base-only rule, plus discovered inheritance reaching actual Engine findings and a nonacting const control; cycle and depth failures have dedicated cases.
+// @evidence contracts/testing.md#execution-ownership TestLoadRuleConfigResolvesLinearExtendsChain is a selected Go unit entry calling LoadRuleConfig, LoadConfigResolver and NewEngineWithResolver directly with exact authored JSON and parsed sources, without installing consumers, native compilation or a product child. The native CLI severity-to-exit transport is covered by the shared command boundary rather than this direct engine case.
+func TestLoadRuleConfigResolvesLinearExtendsChain(t *testing.T) {
+  dir := t.TempDir()
+  writeFile(t, filepath.Join(dir, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(dir, "b.config.json"), `{
+    "rules": { "no-var": "warning", "eqeqeq": "error" }
+  }`)
+  writeFile(t, filepath.Join(dir, "a.config.json"), `{
+    "extends": "./b.config.json",
+    "rules": { "no-var": "error" }
+  }`)
+
+  cfg, err := LoadRuleConfig(&PluginEntry{
+    Config: map[string]any{
+      "configFile": "./a.config.json",
+    },
+  }, dir, "tsconfig.json")
+  if err != nil {
+    t.Fatalf("LoadRuleConfig: %v", err)
+  }
+  if cfg.Severity("eqeqeq") != SeverityError {
+    t.Errorf("eqeqeq: want error inherited from base, got %v", cfg.Severity("eqeqeq"))
+  }
+  if cfg.Severity("no-var") != SeverityError {
+    t.Errorf("noVar: want error from local override, got %v", cfg.Severity("no-var"))
+  }
+
+  discovered := t.TempDir()
+  writeFile(t, filepath.Join(discovered, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(discovered, "lint.config.json"), `{"extends":"./base.config.json"}`)
+  writeFile(t, filepath.Join(discovered, "base.config.json"), `{"rules":{"no-var":"error"}}`)
+  resolver, err := LoadConfigResolver(&PluginEntry{}, discovered, "tsconfig.json")
+  if err != nil {
+    t.Fatalf("discovered extends: %v", err)
+  }
+  engine := NewEngineWithResolver(resolver)
+  if err := engine.ConfigError(); err != nil {
+    t.Fatalf("inherited engine binding: %v", err)
+  }
+  fileName := filepath.Join(discovered, "src", "main.ts")
+  source := "var value = 1;\nexport const ok = value;\n"
+  file := parseTSFile(t, fileName, source)
+  findings := engine.Run([]*shimast.SourceFile{file}, nil)
+  if err := validateSemanticRuleFindings(RuleConfig{"no-var": SeverityError}, findings); err != nil {
+    t.Fatalf("inherited semantic findings: %v", err)
+  }
+  if len(findings) != 1 || findings[0].Rule != "no-var" || findings[0].Severity != SeverityError || findings[0].File != file {
+    t.Fatalf("exact inherited source must report one no-var error: %+v", findings)
+  }
+  valid := parseTSFile(t, fileName, "const value = 1;\nexport const ok = value;\n")
+  if findings := engine.Run([]*shimast.SourceFile{valid}, nil); len(findings) != 0 {
+    t.Fatalf("adjacent const source must remain accepted: %+v", findings)
+  }
+}

package/linthost/load_rules_ignores_non_lint_plugin_payload_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestLoadRulesIgnoresNonLintPluginPayload verifies unknown plugin entries are inert.
+//
+// Disabled plugins are filtered by the host before the sidecar receives
+// --plugins-json, so the lint binary must treat payloads without @ttsc/lint as
+// an empty rule set. Other plugin descriptors should not trigger discovery.
+//
+// This scenario exercises ParsePlugins, FindLintEntry, and loadRules through a
+// payload containing only unrelated or disabled-looking plugin descriptors.
+//
+// 1. Build a plugins-json payload without an @ttsc/lint entry.
+// 2. Load rules through the command helper.
+// 3. Assert the resulting resolver has no enabled rules.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual loadRules on banner transform and disabled-looking unrelated check descriptors returns a resolver with no enabled rules and no error.
+// @evidence contracts/testing.md#independent-expectations Neither authored descriptor has the supported lint identity, so the literal empty enabled configuration follows descriptor-selection semantics rather than checking repository fixture placement.
+// @evidence contracts/testing.md#distinguishing-cases Different unrelated stages and an enabled:false-looking config must remain inert by name; populated lint parsing is a separate positive descriptor control, not a claim that disabled filtering ran.
+// @evidence contracts/testing.md#execution-ownership Actual owning Go loadRules executes in-process with an isolated temporary cwd; no ttsx script evaluator, installed consumer, native producer or separate host is required for the absent lint entry.
+func TestLoadRulesIgnoresNonLintPluginPayload(t *testing.T) {
+  rules, err := loadRules(`[
+    {"name":"@ttsc/banner","stage":"transform","config":{}},
+    {"name":"disabled","stage":"check","config":{"enabled":false}}
+  ]`, t.TempDir(), "tsconfig.json")
+  if err != nil {
+    t.Fatalf("loadRules: %v", err)
+  }
+  if enabled := rules.EnabledRuleConfig(); len(enabled) != 0 {
+    t.Fatalf("non-lint payload should not enable rules, got %+v", enabled)
+  }
+}

package/linthost/loader_module_option_follows_the_config_package_type_test.go

@@ -0,0 +1,103 @@
+package linthost
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLoaderModuleOptionFollowsTheConfigPackageType verifies the ephemeral
+// loader tsconfig derives its `module` option from the nearest package manifest
+// and preserves the generator's explicit-extension and malformed-manifest policy.
+//
+// A `lint.config.ts` is a Node module, and Node decides its format from the
+// package scope it sits in. Hardcoding "ESNext" ran every ambiguous `.ts`
+// config as ESM, so `__dirname` threw in an ordinary CommonJS package (#1068).
+// The generator stops at the first readable manifest: a missing type or malformed
+// JSON selects CommonJS instead of deferring to a module-typed ancestor. That
+// malformed fallback is a synthesis policy, not Node runtime parity: Node's
+// package loader rejects invalid package JSON. Explicit `.cts`/`.mts` inputs keep
+// ESNext here; their extension-specific runtime behavior is not executed below.
+//
+//  1. Build a tree covering each step of the lookup: a manifest with no "type",
+//     a "type": "module" package, nested manifests that override an ancestor in
+//     both directions, a manifest that does not parse, and a directory with no
+//     manifest of its own.
+//  2. Synthesize the loader tsconfig for a config in each.
+//  3. Assert every generated `module` matches the authored policy table.
+//
+// The wildcard `types` entry is pinned alongside as a generated-setting guard.
+// This case does not compile ambient types; the separate `__dirname` consumer
+// case owns its typed config and runtime contribution, not an exhaustive ambient
+// type-package oracle supplied by this JSON comparison.
+//
+// @evidence contracts/testing.md#behavioral-verification typeScriptConfigLoaderTsconfig emits parseable JSON whose module option follows the nearest readable manifest, including the CommonJS malformed-JSON fallback; explicit mts/cts inputs emit ESNext without proving downstream runtime behavior.
+// @evidence contracts/testing.md#independent-expectations Authored nearest manifests and literal CommonJS/ESNext options specify the loader synthesis policy; independent encoding/json decoding observes the generated result.
+// @evidence contracts/testing.md#distinguishing-cases Nearest scopes override opposite ancestors, absent manifests inherit, malformed manifests bound scope, and explicit mts/cts contrast with ambiguous ts/js extensions.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go entry owns the case described above. Authored temporary package scopes reach typeScriptConfigLoaderTsconfig, followed by independent JSON decoding in-process; generated module and types options are inspected without compiling or evaluating the generated loader.
+func TestLoaderModuleOptionFollowsTheConfigPackageType(t *testing.T) {
+  root := t.TempDir()
+  for name, manifest := range map[string]string{
+    "cjs":                 `{"name":"cjs"}`,
+    "cjs/declared-module": `{"name":"declared","type":"module"}`,
+    "esm":                 `{"name":"esm","type":"module"}`,
+    "esm/nested":          `{"name":"nested"}`,
+    "esm/unparseable":     `{"name":`,
+  } {
+    dir := filepath.Join(root, filepath.FromSlash(name))
+    if err := os.MkdirAll(dir, 0o755); err != nil {
+      t.Fatalf("create %s: %v", dir, err)
+    }
+    if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(manifest), 0o644); err != nil {
+      t.Fatalf("write manifest in %s: %v", dir, err)
+    }
+  }
+  deep := filepath.Join(root, "esm", "deep")
+  if err := os.MkdirAll(deep, 0o755); err != nil {
+    t.Fatalf("create %s: %v", deep, err)
+  }
+
+  for _, testCase := range []struct {
+    config string
+    expect string
+    label  string
+  }{
+    {filepath.Join(root, "cjs", "lint.config.ts"), "CommonJS", `a manifest with no "type" means CommonJS`},
+    {filepath.Join(root, "esm", "lint.config.ts"), "ESNext", `an explicit "type": "module"`},
+    {filepath.Join(root, "esm", "nested", "lint.config.ts"), "CommonJS", "the nearest manifest outranks a module-typed ancestor"},
+    {filepath.Join(root, "cjs", "declared-module", "lint.config.ts"), "ESNext", "the nearest manifest outranks a CommonJS ancestor"},
+    {filepath.Join(root, "esm", "unparseable", "lint.config.ts"), "CommonJS", "a manifest that does not parse still bounds the scope"},
+    {filepath.Join(deep, "lint.config.ts"), "ESNext", "a directory with no manifest defers to the enclosing package"},
+    {filepath.Join(root, "esm", "lint.config.cts"), "ESNext", ".cts is left to its extension"},
+    {filepath.Join(root, "cjs", "lint.config.mts"), "ESNext", ".mts is left to its extension"},
+    {filepath.Join(root, "cjs", "lint.config.js"), "CommonJS", "an ambiguous .js follows the same scope"},
+  } {
+    dir := t.TempDir()
+    raw := typeScriptConfigLoaderTsconfig(
+      filepath.Join(dir, "loader.mts"),
+      testCase.config,
+      dir,
+    )
+    var parsed struct {
+      CompilerOptions struct {
+        Module string   `json:"module"`
+        Types  []string `json:"types"`
+      } `json:"compilerOptions"`
+    }
+    if err := json.Unmarshal([]byte(raw), &parsed); err != nil {
+      t.Fatalf("parse generated tsconfig for %s: %v", testCase.label, err)
+    }
+    if parsed.CompilerOptions.Module != testCase.expect {
+      t.Fatalf(
+        "%s: module = %q, want %q",
+        testCase.label,
+        parsed.CompilerOptions.Module,
+        testCase.expect,
+      )
+    }
+    if len(parsed.CompilerOptions.Types) != 1 || parsed.CompilerOptions.Types[0] != "*" {
+      t.Fatalf("%s: types = %#v, want [\"*\"]", testCase.label, parsed.CompilerOptions.Types)
+    }
+  }
+}

package/linthost/loader_rootdir_contains_loader_and_config_test.go

@@ -0,0 +1,59 @@
+package linthost
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoaderRootDirContainsLoaderAndConfig verifies the ephemeral loader
+// tsconfig's rootDir contains both authored `files` entries under the host's path grammar.
+//
+// The loader tsconfig lists two absolute inputs — the generated loader script
+// and the user's config — and tsgo rejects any input outside rootDir with
+// TS6059. The historical hardcoded "/" is not an ancestor of drive-letter
+// paths, so on Windows every TypeScript config evaluation failed (#299,
+// #304); rootDir must be the volume root of the loader directory instead.
+//
+// 1. Synthesize the loader tsconfig for a temp-dir loader and config.
+// 2. Parse the generated JSON.
+// 3. Assert rootDir is slash-terminated and every `files` entry starts with it.
+//
+// @evidence contracts/testing.md#behavioral-verification typeScriptConfigLoaderTsconfig emits two input paths under one slash-terminated rootDir, avoiding a root that excludes the config or loader.
+// @evidence contracts/testing.md#independent-expectations encoding/json independently decodes output and the authored two input locations define required ancestry; this checks generated behavior rather than committed file arrangement.
+// @evidence contracts/testing.md#distinguishing-cases Both loader and config must fit; LoaderModuleOptionFollowsTheConfigPackageType separately owns module mode and TestWindowsLoaderTempBaseStaysOnConfigVolume owns cross-volume placement. This case observes the current host path grammar; the Linux execution alone does not prove Windows drive-root syntax.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit generates loader tsconfig JSON for two authored host-native paths and independently decodes their identities and root ancestry in-process; it does not launch the generated compiler project or certify another OS path grammar.
+func TestLoaderRootDirContainsLoaderAndConfig(t *testing.T) {
+  dir := t.TempDir()
+  raw := typeScriptConfigLoaderTsconfig(
+    filepath.Join(dir, "loader.mts"),
+    filepath.Join(dir, "lint.config.ts"),
+    dir,
+  )
+  var parsed struct {
+    CompilerOptions struct {
+      RootDir string `json:"rootDir"`
+    } `json:"compilerOptions"`
+    Files []string `json:"files"`
+  }
+  if err := json.Unmarshal([]byte(raw), &parsed); err != nil {
+    t.Fatalf("parse generated tsconfig: %v", err)
+  }
+  rootDir := parsed.CompilerOptions.RootDir
+  if !strings.HasSuffix(rootDir, "/") {
+    t.Fatalf("rootDir %q is not a slash-terminated root", rootDir)
+  }
+  if len(parsed.Files) != 2 {
+    t.Fatalf("files mismatch: %#v", parsed.Files)
+  }
+  if parsed.Files[0] != filepath.ToSlash(filepath.Join(dir, "loader.mts")) ||
+    parsed.Files[1] != filepath.ToSlash(filepath.Join(dir, "lint.config.ts")) {
+    t.Fatalf("generated inputs lost their authored identities: %#v", parsed.Files)
+  }
+  for _, file := range parsed.Files {
+    if !strings.HasPrefix(file, rootDir) {
+      t.Fatalf("files entry %q is not under rootDir %q", file, rootDir)
+    }
+  }
+}

package/linthost/loader_temp_base_stays_on_config_volume_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLoaderTempBaseStaysOnConfigVolume verifies portable loader-temp defaults.
+//
+// Same-volume and volume-free relative inputs keep the system-temp default.
+// Actual cross-volume placement and junction identity belong to the Windows boundary batch.
+//
+// 1. Create a config origin next to node_modules.
+// 2. Assert same-volume and relative config inputs retain the empty default.
+//
+// @evidence contracts/testing.md#behavioral-verification loaderTempBase returns the empty system-temp default for a same-volume config and for a relative volume-free config, preventing unnecessary project cache creation.
+// @evidence contracts/testing.md#independent-expectations The historical temp-placement contract retains the default unless a config and temp location have different volumes; independently authored same-root and relative inputs require the literal empty result.
+// @evidence contracts/testing.md#distinguishing-cases Owns same-volume absolute and volume-free relative inputs; TestWindowsLoaderTempBaseStaysOnConfigVolume preserves the differing-volume and kernel-junction branches.
+// @evidence contracts/testing.md#execution-ownership This selected Go unit calls loaderTempBase in-process with an authored fixture directory; it launches no host, installation, native artifact or junction command.
+func TestLoaderTempBaseStaysOnConfigVolume(t *testing.T) {
+  root := t.TempDir()
+  if err := os.MkdirAll(filepath.Join(root, "node_modules"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  config := filepath.Join(root, "lint.config.ts")
+  if base := loaderTempBase(config, root); base != "" {
+    t.Fatalf("same-volume base mismatch: %q", base)
+  }
+  // A relative location has no volume and must keep the historical default,
+  // not be mistaken for a cross-volume config.
+  if base := loaderTempBase("lint.config.ts", root); base != "" {
+    t.Fatalf("relative-location base mismatch: %q", base)
+  }
+}

package/linthost/logic_rules_cover_boolean_call_arguments_undefined_typeof_negative_zero_and_number_nan_test.go

@@ -0,0 +1,43 @@
+package linthost
+
+import "testing"
+
+// TestLogicRulesCoverBooleanCallArgumentsUndefinedTypeofNegativeZeroAndNumberNaN
+// verifies four ESLint behaviors of the equality and boolean rules that the
+// syntax-only versions missed.
+//
+// `Boolean(!!x)` converts twice; `typeof x === undefined` compares a type name
+// with the value undefined; a parenthesized `-0` is still negative zero; and
+// `Number.NaN` is NaN. Each has a twin that the same rule must leave alone.
+//
+//  1. Run no-extra-boolean-cast over `Boolean(!!x)` and `new Boolean(!!x)` and
+//     assert each reports, and over `Boolean(x)` and `String(!!x)` and assert
+//     nothing is reported.
+//  2. Run valid-typeof over `typeof x === undefined` and assert it reports, and
+//     over `typeof x === "undefined"` and assert nothing is reported.
+//  3. Run no-compare-neg-zero over `x === (-0)` and use-isnan over `x === Number.NaN`
+//     and assert each reports, and over `x === 0` and `x === Number.EPSILON` and
+//     assert nothing is reported.
+//
+// @evidence contracts/testing.md#behavioral-verification The four rules must report the Boolean-argument double negation, the undefined identifier compared with typeof, the parenthesized negative zero and Number.NaN, and must keep silent for their ordinary twins.
+// @evidence contracts/testing.md#independent-expectations ESLint documents each shape as incorrect: a Boolean call whose argument is already negated twice, typeof compared with the undefined value, a negative-zero comparison however parenthesized, and a comparison with Number.NaN; the authored literal sources are the oracle.
+// @evidence contracts/testing.md#distinguishing-cases Each reported source has an adjacent source that differs in one property, a plain argument, a string type name, a plain zero or a different Number constant, so dropping a required positive shape or reporting its named control fails the corresponding assertion; this is not a universal text-matcher rejection proof.
+// @evidence contracts/testing.md#execution-ownership TestLogicRulesCoverBooleanCallArgumentsUndefinedTypeofNegativeZeroAndNumberNaN materializes the authored sources through the shared snapshot helper and calls the actual engine in the shared Go unit process; the Boolean rule uses its required Program/checker, while AST-only rules use direct parsing. No consumer install or native build runs.
+func TestLogicRulesCoverBooleanCallArgumentsUndefinedTypeofNegativeZeroAndNumberNaN(t *testing.T) {
+  report := func(rule, source string) {
+    t.Helper()
+    _, _, findings := runRuleFindingsSnapshot(t, rule, source, nil)
+    if len(findings) != 1 {
+      t.Fatalf("%s on %q: want exactly one finding, got %d", rule, source, len(findings))
+    }
+  }
+  report("no-extra-boolean-cast", "declare const x: unknown;\nJSON.stringify(Boolean(!!x));\n")
+  report("no-extra-boolean-cast", "declare const x: unknown;\nJSON.stringify(new Boolean(!!x));\n")
+  assertRuleSkipsSource(t, "no-extra-boolean-cast", "declare const x: unknown;\nJSON.stringify(Boolean(x));\nJSON.stringify(String(!!x));\n")
+  report("valid-typeof", "declare const x: unknown;\nJSON.stringify(typeof x === undefined);\n")
+  assertRuleSkipsSource(t, "valid-typeof", "declare const x: unknown;\nJSON.stringify(typeof x === \"undefined\");\n")
+  report("no-compare-neg-zero", "declare const x: number;\nJSON.stringify(x === (-0));\n")
+  assertRuleSkipsSource(t, "no-compare-neg-zero", "declare const x: number;\nJSON.stringify(x === 0);\n")
+  report("use-isnan", "declare const x: number;\nJSON.stringify(x === Number.NaN);\n")
+  assertRuleSkipsSource(t, "use-isnan", "declare const x: number;\nJSON.stringify(x === Number.EPSILON);\n")
+}