@ttsc/lint 0.30.4 → 0.31.1

package/linthost/no_duplicate_imports_include_exports_reports_type_reexport_after_value_import_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsReportsTypeReexportAfterValueImport
+// verifies `includeExports: true` alone still reports a clause-level
+// `export type` re-export of a module with a value import above.
+//
+// Locks the default type handling on the export arm: without
+// `allowSeparateTypeImports`, an `export type { … } from` declaration
+// joins the ordinary comparison, and named type bindings merge with the
+// named value import. This is the negative twin of the case that adds
+// `allowSeparateTypeImports: true` and expects silence.
+//
+// 1. Import named value bindings from "m", then `export type { … } from "m"`.
+// 2. Run the rule with `includeExports: true` only.
+// 3. Assert exactly one duplicated-as-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Without type separation, a type reexport joins a preceding value import comparison. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations allowSeparateTypeImports defaults false; the authored line-2 export-as-import message is required despite type syntax. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Same fixture is exempt when both separation and export checking are enabled in the companion case.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsReportsTypeReexportAfterValueImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export type { IEntity } from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated as import."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_skips_local_export_without_module_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsSkipsLocalExportWithoutModule
+// verifies `includeExports: true` ignores `export { … }` statements that
+// have no `from` clause.
+//
+// Locks the missing-module guard on the export arm: a local export
+// re-exports nothing and names no module, so it must not join the
+// module-keyed comparison. If the nil `ModuleSpecifier` were keyed under
+// the empty string, two local exports would falsely collide with each
+// other.
+//
+// 1. Import from "m", declare locals, and export them twice without `from`.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Local export clauses do not join a same-module import duplicate comparison. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Exports without a module specifier are not module-loading declarations; authored zero findings follows that boundary. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Two local exports alongside an import detect treating any export clause as a reexport.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsSkipsLocalExportWithoutModule(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+const first = value;
+const second = value;
+export { first };
+export { second };
+`, `{"includeExports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_include_exports_treats_empty_reexport_clause_as_side_effect_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsTreatsEmptyReexportClauseAsSideEffect
+// verifies `export {} from "m"` is categorized as a specifier-less
+// side-effect declaration, not as named bindings.
+//
+// Locks the empty-`NamedExports` branch in
+// `duplicateImportsExportEntry`, mirroring the ESTree reading where an
+// empty block contributes no specifiers. The discriminating pairing is a
+// preceding `export * from "m"`: the side-effect category merges with
+// export-all (finding), while miscategorized named bindings would hit
+// the export-all exclusion and stay silent.
+//
+// 1. Write `export * from "m"` and then `export {} from "m"`.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert exactly one duplicated-export finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. An empty reexport after export-all is a duplicate export. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations export {} from m still carries a module operation with side-effect shape; the authored line-2 message distinguishes empty clause classification. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts empty reexport with namespace reexport acceptance, while default with empty clause is separately not side-effect-only.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsTreatsEmptyReexportClauseAsSideEffect(t *testing.T) {
+  got := runNoDuplicateImports(t, `export * from "m";
+export {} from "m";
+`, `{"includeExports":true}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` export is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_include_exports_with_allow_separate_allows_type_reexport_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsIncludeExportsWithAllowSeparateAllowsTypeReexport
+// verifies combining `includeExports` with `allowSeparateTypeImports`
+// accepts a clause-level `export type` re-export next to a value import
+// of the same module.
+//
+// Locks the clause-level type-ness reading on the export arm
+// (`ExportDeclaration.IsTypeOnly`): the type/value separation must apply
+// to re-exports exactly as it does to imports, so the type-only
+// re-export is exempt from comparison with the value import. If export
+// type-ness were dropped, this pair would report as its
+// includeExports-only twin does.
+//
+// 1. Import named value bindings from "m", then `export type { … } from "m"`.
+// 2. Run the rule with both options enabled.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. The combined export and type-separation options exempt a value import/type reexport pair. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Unlike clause-level categories are exempt under allowSeparateTypeImports even across import/export declarations. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The same pair reports in the no-separation sibling, isolating the option interaction.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsIncludeExportsWithAllowSeparateAllowsTypeReexport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+export type { IEntity } from "m";
+`, `{"includeExports":true,"allowSeparateTypeImports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_preserves_migrated_json_tuple_options_test.go

@@ -0,0 +1,47 @@
+package linthost
+
+import (
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNoDuplicateImportsPreservesMigratedJSONTupleOptions verifies the original
+// built-in options tuple reaches duplicate-import analysis through JSON loading.
+//
+// The type/value pair must stay clean while an ordinary mergeable pair still
+// reports, so neither a lost options object nor an inactive rule can pass.
+//
+// 1. Write the original lint.config.json tuple and five-line source.
+// 2. Discover/load the JSON through LoadConfigResolver and bind it to the engine.
+// 3. Require exactly no-duplicate-imports/error at line 4.
+//
+// @evidence contracts/testing.md#behavioral-verification LoadConfigResolver discovers the lint.config.json written into a temporary project, decodes its `["error", {allowSeparateTypeImports: true}]` tuple, and NewEngineWithResolver.Run executes the rule over the parsed source. The same-module value/type import pair on lines 1-2 stays clean while the two mergeable named imports on lines 3-4 report once, at line 4.
+// @evidence contracts/testing.md#independent-expectations The expected single no-duplicate-imports finding at error severity on line 4 is a literal derived from the rule contract: allowSeparateTypeImports exempts a value import beside a clause-level type import, and does not exempt two value-named imports of one module.
+// @evidence contracts/testing.md#distinguishing-cases One source holds the option-dependent negative (lines 1-2) and the rule-active positive (lines 3-4). The ConfigError check and the EnabledRules severity check prevent a missing or disabled rule from passing as a false zero, and requiring exactly one finding rejects a lost options object, which would also flag line 2.
+// @evidence contracts/testing.md#execution-ownership The Test writes tsconfig.json and lint.config.json into t.TempDir, calls LoadConfigResolver, then runs NewEngineWithResolver.Run over a parseTSFile result in the Go test process. It starts no native host or installed consumer.
+func TestNoDuplicateImportsPreservesMigratedJSONTupleOptions(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), "{}")
+  writeFile(t, filepath.Join(root, "lint.config.json"), `{"rules":{"no-duplicate-imports":["error",{"allowSeparateTypeImports":true}]}}`)
+  source := "import api from \"separate-type-module\";\nimport type { IEntity } from \"separate-type-module\";\nimport { alpha } from \"duplicate-module\";\nimport { beta } from \"duplicate-module\";\nJSON.stringify({ api, alpha, beta });"
+  resolver, err := LoadConfigResolver(&PluginEntry{}, root, "tsconfig.json")
+  if err != nil {
+    t.Fatalf("LoadConfigResolver: %v", err)
+  }
+  engine := NewEngineWithResolver(resolver)
+  if err := engine.ConfigError(); err != nil {
+    t.Fatalf("NewEngineWithResolver: %v", err)
+  }
+  if engine.EnabledRules()["no-duplicate-imports"] != SeverityError {
+    t.Fatal("JSON tuple did not enable no-duplicate-imports at error severity")
+  }
+  file := parseTSFile(t, filepath.Join(root, "src", "main.ts"), source)
+  findings := engine.Run([]*shimast.SourceFile{file}, nil)
+  actual := normalizeRuleFindings(file, findings)
+  expected := ruleExpectation{Rule: "no-duplicate-imports", Severity: SeverityError, Line: 4}
+  if len(actual) != 1 || actual[0] != expected {
+    t.Fatalf("want exactly %+v, got %+v", expected, actual)
+  }
+}

package/linthost/no_duplicate_imports_reports_default_then_named_value_imports_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsDefaultThenNamedValueImports verifies
+// no-duplicate-imports reports a named value import following a default
+// value import of the same module.
+//
+// Locks the mergeable cross-category pairing in
+// `duplicateImportsCanMerge`: a default binding and named bindings share
+// one legal declaration (`import def, { a } from "m"`), so the pair is a
+// duplicate even though the categories differ. This is the value-kind
+// negative twin of the type-only default/named exemption, which must not
+// leak into value declarations.
+//
+// 1. Import a default binding and then named bindings from one module.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Default then named value imports report the second as a duplicate. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations TypeScript permits one declaration with default and named bindings; the authored line-2 message follows mergeability. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts with type-only default/named and value named/namespace nonmergeable pairs.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsDefaultThenNamedValueImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import def from "m";
+import { named } from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_default_then_namespace_value_imports_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsDefaultThenNamespaceValueImports verifies
+// no-duplicate-imports reports a namespace import following a default
+// import of the same module.
+//
+// Locks the mergeable default/namespace pairing: `import def, * as ns
+// from "m"` is legal TypeScript, so the two declarations consolidate and
+// the second one is a duplicate. Guards against widening the
+// namespace/named exclusion in `duplicateImportsCanMerge` to every
+// namespace pairing.
+//
+// 1. Import a default binding and then a namespace binding from one module.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Default then namespace value imports report the second as a duplicate. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations TypeScript permits a default and namespace clause together; the authored line-2 message expresses that consolidation. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Differs from named/namespace acceptance even though both use a namespace binding.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsDefaultThenNamespaceValueImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import def from "m";
+import * as namespace from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_each_later_duplicate_import_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsEachLaterDuplicateImport verifies three
+// mergeable imports of one module produce a finding on the second AND
+// the third declaration.
+//
+// Locks one finding per later declaration, rather than one finding for the
+// module or one per earlier pairing. Each later named import can already
+// merge with the first, so this fixture does not prove reported declarations
+// remain recorded for comparisons with different declaration categories.
+//
+// 1. Import named bindings from the same module three times.
+// 2. Run the rule with default options.
+// 3. Assert duplicate-import findings on lines two and three.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Three named imports report both the second and third declarations. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Both later declarations duplicate the first module operation; the authored two-entry list detects lost or extra reports. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Repeated history must produce one report per later import, not one total or one per earlier pair.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsEachLaterDuplicateImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { first } from "m";
+import { second } from "m";
+import { third } from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+    {Line: 3, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_nonadjacent_duplicate_value_imports_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsNonadjacentDuplicateValueImports verifies
+// no-duplicate-imports reports a duplicate even when an unrelated import
+// sits between the two same-module declarations.
+//
+// Locks the per-module bookkeeping in the rule's `modules` map: the
+// duplicate comparison keys on the module specifier, not on adjacency,
+// so an intervening import of a different module must neither reset the
+// tracking nor produce a finding of its own.
+//
+// 1. Import from "m", then from an unrelated module, then from "m" again.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the third line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. An unrelated intervening module does not hide the later duplicate at line 3. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Duplicate identity is module-based across the source, not adjacency-based; the authored line and m message fix that expectation. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The other-module middle statement is a negative control and a state-retention boundary.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsNonadjacentDuplicateValueImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { first } from "m";
+import { other } from "other";
+import { second } from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 3, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_repeated_side_effect_imports_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsRepeatedSideEffectImports verifies
+// no-duplicate-imports reports a second bare side-effect import of the
+// same module.
+//
+// Locks the SideEffectImport category from `duplicateImportsImportEntry`
+// on the clause-less shape: two `import "m"` declarations trivially
+// consolidate into one, and the official implementation treats the
+// side-effect category as mergeable with every import category.
+//
+// 1. Write the same bare `import "m"` twice.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Two same-module side-effect imports report the second. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The module executes once and duplicate side-effect syntax is consolidatable; the literal line-2 message is independent of findings. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases No bindings exist, distinguishing module side effects from named or namespace clause handling.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsRepeatedSideEffectImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import "m";
+import "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_side_effect_import_after_named_import_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsSideEffectImportAfterNamedImport verifies
+// no-duplicate-imports reports a bare side-effect import of a module
+// that already has a named import above.
+//
+// Locks the cross-category mergeability of the side-effect shape: the
+// module already loads through the named declaration, so the bare
+// `import "m"` folds into it. The official mergeability table exempts
+// the side-effect category from every exclusion, and this pins that the
+// port did not accidentally isolate it.
+//
+// 1. Import named bindings from "m", then a bare `import "m"`.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. A side-effect import after a named import of the same module reports the second. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The named import already performs the module operation, so the later side-effect declaration is redundant. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases This asymmetrical declaration pair complements repeated side effects and export-all/side-effect order coverage.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsSideEffectImportAfterNamedImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { named } from "m";
+import "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_two_namespace_value_imports_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsTwoNamespaceValueImports verifies
+// no-duplicate-imports reports two namespace imports of the same module.
+//
+// Positive twin of the namespace/named exclusion: the guard in
+// `duplicateImportsCanMerge` only excludes namespace-beside-named pairs,
+// while two namespace bindings of one module remain an ordinary
+// duplicate (one binding can serve both call sites). An over-broad
+// namespace exemption would silently stop reporting this shape.
+//
+// 1. Import `* as a` and `* as b` from the same module.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Two same-module namespace value imports report the second. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Namespace aliases do not require two module operations; the authored exact duplicate message is independent of alias spelling. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts two namespace clauses with named/namespace forms that cannot share one declaration.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsTwoNamespaceValueImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import * as first from "m";
+import * as second from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_two_type_default_imports_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsTwoTypeDefaultImports verifies two
+// type-only default imports of the same module are still reported.
+//
+// Positive twin of the ESLint 9.30.1 exemption: the type-only guard in
+// `duplicateImportsCanMerge` excludes only the default/named pairing.
+// Two type-only defaults reference the same export and reduce to one
+// declaration, so widening the guard to every type-only pair would be a
+// regression this case catches.
+//
+// 1. Import two type-only default bindings from the same module.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Two type-only default imports of the same module report the second. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Both bind the same default type and are redundant; the authored line-2 duplicate differs from incompatible type default/named acceptance. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Same-category default pair guards against exempting all type-only imports.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsTwoTypeDefaultImports(t *testing.T) {
+  got := runNoDuplicateImports(t, `import type First from "m";
+import type Second from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_value_default_then_type_named_import_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsValueDefaultThenTypeNamedImport verifies
+// the default configuration reports a clause-level type named import
+// after a value default import of the same module.
+//
+// Pins the both-type precondition of the ESLint 9.30.1 guard in
+// `duplicateImportsCanMerge`: the default/named exemption applies only
+// when BOTH declarations are type-only. This pair has the exempted
+// category shape (default beside named) but only one type-only side, so
+// it merges into `import def, { type Named } from "m"` and must report.
+// A guard loosened to exempt the pair when either side is type-only
+// would go silent here.
+//
+//  1. Import a value default binding, then clause-level named type
+//     bindings, from one module.
+//  2. Run the rule with default options.
+//  3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Value default followed by type named import reports the second under defaults. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The default option includes unlike type categories and this pair is consolidatable under a value declaration. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts type-only default/named acceptance and enabled mixed-category separation.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsValueDefaultThenTypeNamedImport(t *testing.T) {
+  got := runNoDuplicateImports(t, `import def from "m";
+import type { Named } from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_reports_value_then_type_named_import_by_default_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsReportsValueThenTypeNamedImportByDefault
+// verifies the default configuration reports a clause-level `import
+// type` declaration whose module already has a value import above.
+//
+// Locks the official default `allowSeparateTypeImports: false`: without
+// the option, clause-level type declarations join the ordinary duplicate
+// comparison, and named value bindings merge with named type bindings
+// into `import { a, type B } from "m"`. This is the negative twin of the
+// option-enabled acceptance case.
+//
+// 1. Import named value bindings and then clause-level type bindings from "m".
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Value named followed by clause-level type named import reports the second under defaults. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations Default allowSeparateTypeImports is false; literal line-2 duplicate requires comparison across categories. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The correctly enabled separation sibling provides the negative side of this option gate.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsReportsValueThenTypeNamedImportByDefault(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { value } from "m";
+import type { Entity } from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}

package/linthost/no_duplicate_imports_skips_empty_module_specifiers_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsSkipsEmptyModuleSpecifiers verifies imports with
+// an empty (or whitespace-only) module string never participate in the
+// duplicate comparison.
+//
+// Locks the empty-module guard: the official `handleImportsExports`
+// skips declarations whose trimmed module name is falsy, so even two
+// identical empty-specifier imports are not duplicates of each other.
+// Removing the guard would key both under "" and report the second.
+//
+//  1. Write two `import { … } from ""` declarations and two identical
+//     whitespace-only specifiers.
+//  2. Run the rule with default options.
+//  3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. Empty and whitespace-only module specifiers produce no duplicate findings. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The supported normalization ignores empty module keys; zero expectations are authored rather than inferred from scanner output. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Two empty strings and two identical whitespace-only specifiers distinguish empty-key rejection from ordinary nonempty duplicate tracking.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsSkipsEmptyModuleSpecifiers(t *testing.T) {
+  got := runNoDuplicateImports(t, `import { first } from "";
+import { second } from "";
+import { third } from "  ";
+import { fourth } from "  ";
+`, `{}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_treats_default_with_empty_named_clause_as_default_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsTreatsDefaultWithEmptyNamedClauseAsDefault
+// verifies `import def, {} from "m"` is categorized as a default import,
+// not as a side-effect import.
+//
+// Locks the fall-through order in `duplicateImportsImportEntry`: an
+// empty named block contributes no specifiers, so the default binding
+// decides the category — mirroring the official specifier scan that
+// falls back to `specifiers[0]`. The discriminating pairing is an
+// earlier `export * from "m"`: a default binding cannot merge with
+// export-all (silence), while a miscategorized side-effect import would
+// merge and report.
+//
+// 1. Write `export * from "m"`, then `import def, {} from "m"`.
+// 2. Run the rule with `includeExports: true`.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. A default import with an empty named clause remains nonmergeable with export-all. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations The existing default binding prevents the declaration being side-effect-only; TypeScript binding shape establishes zero findings. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts bare empty named clauses and empty reexports, which are separately tested as side-effect forms.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertNoDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsTreatsDefaultWithEmptyNamedClauseAsDefault(t *testing.T) {
+  got := runNoDuplicateImports(t, `export * from "m";
+import def, {} from "m";
+`, `{"includeExports":true}`)
+  assertNoDuplicateImportsFindings(t, got)
+}

package/linthost/no_duplicate_imports_treats_empty_named_import_clause_as_side_effect_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoDuplicateImportsTreatsEmptyNamedImportClauseAsSideEffect
+// verifies `import {} from "m"` is categorized as a side-effect import,
+// not as named bindings.
+//
+// Locks the empty-`NamedImports` branch in
+// `duplicateImportsImportEntry`. In ESTree an empty block contributes no
+// specifiers, so the official rule categorizes the declaration as
+// SideEffectImport. The discriminating pairing is a preceding namespace
+// import: side-effect merges with namespace (finding), while a
+// miscategorized named clause would hit the namespace/named exclusion
+// and stay silent.
+//
+// 1. Import `* as ns` from "m", then `import {} from "m"`.
+// 2. Run the rule with default options.
+// 3. Assert exactly one duplicate-import finding on the second line.
+//
+// @evidence contracts/testing.md#behavioral-verification runNoDuplicateImports exercises the actual no-duplicate-imports Engine operation. An empty named import after a namespace import reports as a duplicate. The shared runner also rejects unexpected rules and any offered autofix.
+// @evidence contracts/testing.md#independent-expectations With no default or named bindings, import {} retains only the module operation and can be folded into the earlier namespace import. The helper only normalizes returned line/message pairs and compares them with literal expectations.
+// @evidence contracts/testing.md#distinguishing-cases The empty braces after a namespace import report, which a named binding would not (a namespace import and named bindings cannot share one declaration). The default-plus-empty form `import def, {} from "m"` is owned by TestNoDuplicateImportsTreatsDefaultWithEmptyNamedClauseAsDefault.
+// @evidence contracts/testing.md#execution-ownership runNoDuplicateImports calls parseTSFile and NewEngineWithResolver.Run for this entry's authored source/options, then assertDuplicateImportsFindings performs the displayed literal result comparison. This Test owns that source and option combination in the Go process, without dynamic registration or a native host.
+func TestNoDuplicateImportsTreatsEmptyNamedImportClauseAsSideEffect(t *testing.T) {
+  got := runNoDuplicateImports(t, `import * as namespace from "m";
+import {} from "m";
+`, `{}`)
+  assertDuplicateImportsFindings(t, got, []duplicateImportsFinding{
+    {Line: 2, Message: "`m` import is duplicated."},
+  })
+}