@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_sort_imports_keeps_conflicting_defaults_separate_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsConflictingDefaultsSeparate verifies two distinct
+// default imports of the same module are not merged.
+//
+// Merging would have to pick one default name; the rule declines and keeps both
+// declarations, still grouped and sorted relative to other modules.
+//
+//  1. Parse a file with two different defaults from the same module plus a
+//     later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the conflicting defaults remain two declarations.
+//
+// @evidence contracts/testing.md#behavioral-verification Both default b and default a imports from m must survive separately in original equal-module order while moving before z and preserving all uses.
+// @evidence contracts/testing.md#independent-expectations Each distinct default name is an accessible local binding. The authored full output refuses name loss under supported conflict handling while independently fixing module order.
+// @evidence contracts/testing.md#distinguishing-cases Two distinct defaults cannot occupy one merged default slot. The compatible default-plus-named peer supplies its merge positive; byte-identical namespace duplicates exercise a different protection.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsConflictingDefaultsSeparate owns its literal conflicting-default source, full output and explicit unsafe options in the selected public Go unit population. Parsing, owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsConflictingDefaultsSeparate(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import b from \"m\";\n" +
+    "import a from \"m\";\n" +
+    "z;\n" +
+    "a;\n" +
+    "b;\n"
+  expected := "import b from \"m\";\n" +
+    "import a from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n" +
+    "a;\n" +
+    "b;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_default_gap_comment_unmerged_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsDefaultGapCommentUnmerged verifies protected declaration bytes
+// survive when runtime merging is otherwise permitted.
+//
+// Comments between a default binding and its named list must survive. The unsafe negative distinguishes this prefix protection from the default runtime-order barrier.
+//
+// 1. Assert the original default-mode input produces no finding.
+// 2. Assert the same input stays silent with unsafe runtime sorting enabled.
+// 3. Remove only the protected comment and assert the full merged output.
+//
+// @evidence contracts/testing.md#behavioral-verification The default D plus named a declaration must retain its gap comment and remain separate from b even with unsafe runtime sorting enabled.
+// @evidence contracts/testing.md#independent-expectations Literal original declaration bytes preserve D, a, b and the keep comment; the independent comment-free output legally combines one default and two named bindings.
+// @evidence contracts/testing.md#distinguishing-cases A comment sits between default D and the comma, outside the named braces. Its removed-comment twin merges, contrasting the named-list and default-only gap peers.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsDefaultGapCommentUnmerged owns its literal default/unsafe negatives and comment-free full-output positive in the selected public Go unit population. The syntax-only rule and fixture edit application execute in one Go process without native builds, consumer installation or product-host children.
+func TestFormatSortImportsKeepsDefaultGapCommentUnmerged(t *testing.T) {
+  assertRuleSkipsSource(t, "format/sort-imports", `import D /* keep */, { a } from "m";
+import { b } from "m";
+`)
+  assertRuleSkipsSourceWithOptions(t, "format/sort-imports", "import D /* keep */, { a } from \"m\";\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import D, { a } from \"m\";\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`, "import D, { a, b } from \"m\";\n")
+}

package/linthost/format_sort_imports_keeps_default_only_gap_comment_unmerged_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsDefaultOnlyGapCommentUnmerged verifies protected declaration bytes
+// survive when runtime merging is otherwise permitted.
+//
+// A default-only declaration can contain a prefix comment despite having no named list. Its comment must remain attached when runtime rewriting is permitted.
+//
+// 1. Assert the original default-mode input produces no finding.
+// 2. Assert the same input stays silent with unsafe runtime sorting enabled.
+// 3. Remove only the protected comment and assert the full merged output.
+//
+// @evidence contracts/testing.md#behavioral-verification The default-only a declaration must preserve its keep comment and stay separate from b under both runtime permission modes.
+// @evidence contracts/testing.md#independent-expectations The literal input keeps comment attachment, module and binding identity. The comment-free positive uses supported default-plus-named import grammar rather than copying merge internals.
+// @evidence contracts/testing.md#distinguishing-cases The commented declaration has no named-import list. A comment-free a plus b twin must merge, proving the prefix guard applies before that shape can return early.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsDefaultOnlyGapCommentUnmerged owns its literal default/unsafe negatives and comment-free full-output positive in the selected public Go unit population. The syntax-only rule and fixture edit application execute in one Go process without native builds, consumer installation or product-host children.
+func TestFormatSortImportsKeepsDefaultOnlyGapCommentUnmerged(t *testing.T) {
+  assertRuleSkipsSource(t, "format/sort-imports", `import a /* keep */ from "m";
+import { b } from "m";
+`)
+  assertRuleSkipsSourceWithOptions(t, "format/sort-imports", "import a /* keep */ from \"m\";\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import a from \"m\";\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`, "import a, { b } from \"m\";\n")
+}

package/linthost/format_sort_imports_keeps_empty_named_imports_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsEmptyNamedImports verifies two empty named imports
+// of the same module are not collapsed into a malformed declaration.
+//
+// A merge that would yield neither a default binding nor any specifier is
+// rejected; the originals are kept so `import {} from "m"` never degrades to
+// `import  from "m"`.
+//
+//  1. Parse two `import {}` declarations from the same module plus a
+//     later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the empty imports survive as separate declarations.
+//
+// @evidence contracts/testing.md#behavioral-verification Both empty named imports from m must remain valid separate declarations before z, with z use unchanged.
+// @evidence contracts/testing.md#independent-expectations A merge result with neither default nor named bindings cannot be emitted as import from. The literal complete source preserves both authored dependency declarations under the supported empty-bucket policy.
+// @evidence contracts/testing.md#distinguishing-cases Two empty runtime declarations contrast nonempty duplicate-module merging and the empty type-named plus type-default legal merge boundary. Unsafe sorting is explicitly allowed.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsEmptyNamedImports owns its literal empty-binding declarations, complete sorted output and unsafe options in the selected public Go unit population. Parsing, owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsEmptyNamedImports(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import {} from \"m\";\n" +
+    "import {} from \"m\";\n" +
+    "z;\n"
+  expected := "import {} from \"m\";\n" +
+    "import {} from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_identical_commented_imports_unmerged_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsIdenticalCommentedImportsUnmerged verifies two
+// byte-identical comment-bearing imports are re-emitted verbatim rather than
+// merged into a comment-less declaration.
+//
+// Like namespace imports, comment-bearing declarations get a per-declaration
+// merge key that embeds the original text, so byte-identical duplicates (a
+// duplicate-binding error TypeScript reports later, which the parse-level
+// formatter still sees) collide into one bucket. Without the guard in
+// `renderMergedDecl` the rebuilt statement would join bare specifier texts
+// and silently drop the comment bytes.
+//
+//  1. Parse two identical named imports carrying a specifier comment plus a
+//     later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert both commented declarations survive verbatim, sorted first.
+//
+// @evidence contracts/testing.md#behavioral-verification Both identical comment-bearing a imports must remain verbatim and separate before z; each keep comment and z use must survive.
+// @evidence contracts/testing.md#independent-expectations The parser-visible duplicate declarations are deliberately malformed bindings, yet formatting must not delete their comments. Literal full output independently retains both payload copies under permitted sorting.
+// @evidence contracts/testing.md#distinguishing-cases Byte-identical comments share spelling but still require two declaration copies. Different commented siblings and identical namespace declarations provide complementary protection paths.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsIdenticalCommentedImportsUnmerged owns its duplicate commented parse input and exact two-copy output under unsafe sorting in the selected public Go unit population. Parsing, owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsIdenticalCommentedImportsUnmerged(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import { a /* keep */ } from \"m\";\n" +
+    "import { a /* keep */ } from \"m\";\n" +
+    "z;\n"
+  expected := "import { a /* keep */ } from \"m\";\n" +
+    "import { a /* keep */ } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_identical_namespace_imports_unmerged_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsIdenticalNamespaceImportsUnmerged verifies two
+// byte-identical `default, * as ns` imports are re-emitted verbatim rather
+// than merged into a namespace-less declaration.
+//
+// mergeKey isolates namespace imports by embedding the original text in the
+// key, so two byte-identical declarations (a duplicate-binding error
+// TypeScript reports later, which the parse-level formatter still sees)
+// collide into one bucket. Without the namespace guard in `renderMergedDecl`
+// the rebuilt statement would keep only the default binding and silently
+// drop `* as N`.
+//
+//  1. Parse two identical `import D, * as N` declarations plus a
+//     later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert both namespace declarations survive verbatim, sorted first.
+//
+// @evidence contracts/testing.md#behavioral-verification Both identical D plus namespace N imports must remain separate and verbatim before z, preserving all namespace text and z use.
+// @evidence contracts/testing.md#independent-expectations Duplicate-binding input remains visible to a syntax-only formatter. The literal full output independently forbids dropping either namespace clause while fixing the permitted module order.
+// @evidence contracts/testing.md#distinguishing-cases Two byte-identical default/namespace declarations distinguish repeated-key safety from different namespace/named siblings. Identical commented-import hosts cover another protected payload shape.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsIdenticalNamespaceImportsUnmerged owns its duplicate namespace parse input and exact two-copy output under unsafe sorting in the selected public Go unit population. Parsing, owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsIdenticalNamespaceImportsUnmerged(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import D, * as N from \"m\";\n" +
+    "import D, * as N from \"m\";\n" +
+    "z;\n"
+  expected := "import D, * as N from \"m\";\n" +
+    "import D, * as N from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_namespace_imports_separate_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsNamespaceImportsSeparate verifies a namespace
+// import is never folded into a named import of the same module.
+//
+// `import * as ns` cannot share a declaration with `{ named }`, so the rule
+// keeps namespace declarations standalone while still sorting the block.
+//
+//  1. Parse a file with a namespace and a named import of the same module plus
+//     a later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the namespace import stays its own declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification Namespace ns and named a imports from m must remain separate before z while all ns,a,z uses remain unchanged.
+// @evidence contracts/testing.md#independent-expectations TypeScript import grammar permits a namespace or named list after a default, not a combined namespace-plus-named slot. Literal output independently preserves both local bindings and valid syntax.
+// @evidence contracts/testing.md#distinguishing-cases Namespace and named imports share a module but cannot fold into one named declaration. Default-plus-named merging is compatible, and identical namespaces supply the duplicate-input boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsNamespaceImportsSeparate owns its namespace/named source, exact complete sorted output and unsafe options in the selected public Go unit population. Parsing, owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsNamespaceImportsSeparate(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import * as ns from \"m\";\n" +
+    "import { a } from \"m\";\n" +
+    "z;\n" +
+    "ns;\n" +
+    "a;\n"
+  expected := "import * as ns from \"m\";\n" +
+    "import { a } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n" +
+    "ns;\n" +
+    "a;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_trailing_specifier_comment_unmerged_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsTrailingSpecifierCommentUnmerged verifies protected declaration bytes
+// survive when runtime merging is otherwise permitted.
+//
+// A comment after the module string belongs to that declaration. Its position outside the import prefix must not allow a merge to discard it.
+//
+// 1. Assert the original default-mode input produces no finding.
+// 2. Assert the same input stays silent with unsafe runtime sorting enabled.
+// 3. Remove only the protected comment and assert the full merged output.
+//
+// @evidence contracts/testing.md#behavioral-verification The comment after module m must survive with both declarations separate even when runtime sorting is explicitly allowed.
+// @evidence contracts/testing.md#independent-expectations The authored module-tail comment belongs to the original declaration. The independent comment-free output imports a and b from the same module without deleting user payload.
+// @evidence contracts/testing.md#distinguishing-cases The comment follows the module string and precedes the semicolon, unlike prefix or between-import comments. Removing it supplies the eligible merge positive.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsTrailingSpecifierCommentUnmerged owns its literal default/unsafe negatives and comment-free full-output positive in the selected public Go unit population. The syntax-only rule and fixture edit application execute in one Go process without native builds, consumer installation or product-host children.
+func TestFormatSortImportsKeepsTrailingSpecifierCommentUnmerged(t *testing.T) {
+  assertRuleSkipsSource(t, "format/sort-imports", `import { a } from "m" /* keep */;
+import { b } from "m";
+`)
+  assertRuleSkipsSourceWithOptions(t, "format/sort-imports", "import { a } from \"m\" /* keep */;\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import { a } from \"m\";\nimport { b } from \"m\";\n", `{"unsafeSortRuntimeImports":true}`, "import { a, b } from \"m\";\n")
+}

package/linthost/format_sort_imports_keeps_type_and_value_separate_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsTypeAndValueSeparate verifies that without
+// combineTypeAndValue a value import and a type-only import of the same module
+// stay distinct declarations.
+//
+// The two have different merge keys by default, so they are grouped and sorted
+// but never folded together.
+//
+//  1. Parse a value import and a type-only import of the same module plus a
+//     later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the value and type-only imports remain separate.
+//
+// @evidence contracts/testing.md#behavioral-verification Unsafe sorting without combine must move m before z while retaining separate value foo and type Bar declarations plus foo use.
+// @evidence contracts/testing.md#independent-expectations The supported default keeps type and value declarations distinct. The literal whole-file output independently preserves binding phases while specifying permitted module order.
+// @evidence contracts/testing.md#distinguishing-cases Runtime sorting is allowed but combining is absent; the combine-enabled host is the adjacent merge positive and combine-only host is the runtime-permission negative.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsTypeAndValueSeparate owns the literal full-output sorted-but-uncombined mixed import fixture in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsTypeAndValueSeparate(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import { foo } from \"m\";\n" +
+    "import type { Bar } from \"m\";\n" +
+    "foo;\n"
+  expected := "import { foo } from \"m\";\n" +
+    "import type { Bar } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "foo;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_type_default_and_type_named_separate_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparate verifies a
+// type-only default import and a type-only named import of the same module
+// are not merged into one declaration.
+//
+// Locks the all-type-only guard in `renderMergedDecl`: merging would emit
+// `import type D, { A } from "m"`, which TypeScript rejects with TS1363 ("A
+// type-only import can specify a default import or named bindings, but not
+// both"). The merge is refused to preserve valid type-only declarations
+// and both declarations survive, still grouped and sorted.
+//
+//  1. Parse a type-only default import and a type-only named import of the
+//     same module plus a later-sorting third-party import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the two type-only declarations stay separate, sorted first.
+//
+// @evidence contracts/testing.md#behavioral-verification Sorting must place both m imports before z while retaining separate type-default D and type-named A declarations and the z use.
+// @evidence contracts/testing.md#independent-expectations The official TypeScript Modules Reference prohibits a type-only declaration from containing both default and named bindings. Literal separate declarations preserve legal type syntax under permitted sorting.
+// @evidence contracts/testing.md#distinguishing-cases Both m declarations are type-only but contribute default and named bindings. The combine-enabled twin covers the alternative key path; the empty-named peer supplies the legal merge boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparate owns the authored type-default/type-named sorting snapshot and unsafe options in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparate(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import type D from \"m\";\n" +
+    "import type { A } from \"m\";\n" +
+    "z;\n"
+  expected := "import type D from \"m\";\n" +
+    "import type { A } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_type_default_and_type_named_separate_when_combining_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparateWhenCombining
+// verifies the TS1363 guard also holds when `combineTypeAndValue` routes the
+// two type-only declarations through the shared value merge key.
+//
+// With `combineTypeAndValue: true` both declarations land in the `v\0m`
+// bucket instead of `t\0m`, but the bucket is still wholly type-only, so a
+// merge would produce the same illegal `import type D, { A } from "m"`
+// shape. The guard keys off the merged type-only state, not the bucket key,
+// so both option settings refuse the merge.
+//
+//  1. Parse a type-only default import and a type-only named import of the
+//     same module plus a later-sorting third-party import.
+//  2. Enable combineTypeAndValue and unsafe runtime sorting.
+//  3. Assert the two type-only declarations stay separate, sorted first.
+//
+// @evidence contracts/testing.md#behavioral-verification With both options enabled the type-only D and A declarations must remain separate, move before z and preserve z use.
+// @evidence contracts/testing.md#independent-expectations Official TypeScript module grammar forbids a combined type-only default-plus-named declaration irrespective of the sorter option. The literal output independently retains legal source forms.
+// @evidence contracts/testing.md#distinguishing-cases The whole bucket is type-only even with combine enabled. Its disabled-combine twin and empty-named merge positive distinguish option state from actual grammar legality.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparateWhenCombining owns the literal both-options type-only default/named protection snapshot in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsTypeDefaultAndTypeNamedSeparateWhenCombining(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import type D from \"m\";\n" +
+    "import type { A } from \"m\";\n" +
+    "z;\n"
+  expected := "import type D from \"m\";\n" +
+    "import type { A } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "z;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"combineTypeAndValue":true,"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_keeps_type_default_separate_when_combining_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsTypeDefaultSeparateWhenCombining verifies a
+// type-only default import is not folded into a value import even with
+// combineTypeAndValue on.
+//
+// `import type D, { value }` would retype `value`, so the merge is refused and
+// the declarations stay separate while still grouped and sorted.
+//
+//  1. Parse a type-only default import and a value import of the same module
+//     plus a later-sorting third-party import.
+//  2. Enable combineTypeAndValue and unsafe runtime sorting.
+//  3. Assert the type-only default import stays its own declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification Type-only default D must remain separate from value x when sorting both before z with combining enabled, retaining x use.
+// @evidence contracts/testing.md#independent-expectations A merged clause-level type would erase x as a value binding; dropping type would promote D. The literal output independently preserves each binding phase under the supported combine safety contract.
+// @evidence contracts/testing.md#distinguishing-cases A type-only default and runtime named value cannot merge. A type-only named binding can become inline type in the combines host, and a value default can legally merge in its own host.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsTypeDefaultSeparateWhenCombining owns the full-output mixed type-default/value-named protection fixture in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsKeepsTypeDefaultSeparateWhenCombining(t *testing.T) {
+  source := "import { z } from \"z\";\n" +
+    "import type D from \"m\";\n" +
+    "import { x } from \"m\";\n" +
+    "x;\n"
+  expected := "import type D from \"m\";\n" +
+    "import { x } from \"m\";\n" +
+    "import { z } from \"z\";\n" +
+    "x;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"combineTypeAndValue":true,"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_merges_default_and_named_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsMergesDefaultAndNamed verifies a default import and a
+// named import of the same module merge into one declaration.
+//
+// The default binding survives alongside the union of named specifiers.
+//
+//  1. Parse a file importing `{ b }` and a default from the same module.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert one merged `default, { named }` declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification Unsafe same-module merging must produce default a plus named b in one declaration while retaining both subsequent uses.
+// @evidence contracts/testing.md#independent-expectations TypeScript import grammar permits one default binding followed by named bindings. Literal complete output independently keeps each local name and dependency module.
+// @evidence contracts/testing.md#distinguishing-cases One value default and one named import are compatible, unlike distinct conflicting defaults and type-only default/named peers. Runtime opt-in is explicit.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsMergesDefaultAndNamed owns the literal default-plus-named value merge snapshot and unsafe options in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsMergesDefaultAndNamed(t *testing.T) {
+  source := "import { b } from \"m\";\n" +
+    "import a from \"m\";\n" +
+    "a;\n" +
+    "b;\n"
+  expected := "import a, { b } from \"m\";\n" +
+    "a;\n" +
+    "b;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_merges_duplicate_modules_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsMergesDuplicateModules verifies two value imports of the
+// same module collapse into one declaration with the union of named specifiers.
+//
+// Duplicate runtime merging is available only through the explicit unsafe
+// option; once enabled, the merged specifier list is de-duplicated and sorted.
+//
+//  1. Parse a file importing `{ b }` and `{ a }` from the same module.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert one merged, sorted declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification Two m value declarations must merge into alphabetical a,b while preserving both subsequent uses.
+// @evidence contracts/testing.md#independent-expectations The supported unsafe same-module merge contract unions distinct local bindings. The authored whole-file literal independently preserves the module and both names while fixing their order.
+// @evidence contracts/testing.md#distinguishing-cases Distinct a/b bindings contribute to one module, unlike repeated-local deduplication and conflicting-default protection; the safe runtime block host covers absent permission.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsMergesDuplicateModules owns the authored same-module value merge snapshot and unsafe options in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsMergesDuplicateModules(t *testing.T) {
+  source := "import { b } from \"m\";\n" +
+    "import { a } from \"m\";\n" +
+    "a;\n" +
+    "b;\n"
+  expected := "import { a, b } from \"m\";\n" +
+    "a;\n" +
+    "b;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_merges_duplicate_type_only_imports_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsMergesDuplicateTypeOnlyImports verifies two `import type`
+// declarations of the same module merge into one, staying type-only.
+//
+// When every merged declaration is type-only, the merged result keeps the
+// clause-level `type` keyword rather than marking each specifier inline.
+//
+//  1. Parse a file with two `import type` declarations from the same module.
+//  2. Apply the rule with default options.
+//  3. Assert one merged `import type` declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification The B and A declarations must merge into one clause-level type import with A,B, preserving their type-only classification.
+// @evidence contracts/testing.md#independent-expectations Type-only imports are erased under the official TypeScript module contract. A literal clause-level type declaration independently preserves both type names without adding runtime dependencies.
+// @evidence contracts/testing.md#distinguishing-cases All declarations are type-only and default options suffice. The mixed value/type host requires explicit runtime permission and inline type markers instead.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsMergesDuplicateTypeOnlyImports owns the authored default-options erased-type merge snapshot in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsMergesDuplicateTypeOnlyImports(t *testing.T) {
+  source := "import type { B } from \"m\";\n" +
+    "import type { A } from \"m\";\n"
+  expected := "import type { A, B } from \"m\";\n"
+  assertFixSnapshot(t, "format/sort-imports", source, expected)
+}

package/linthost/format_sort_imports_merges_type_default_with_empty_named_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsMergesTypeDefaultWithEmptyNamed verifies a type-only
+// default import still merges with an empty type-only named import of the
+// same module.
+//
+// Boundary of the TS1363 guard in `renderMergedDecl`: the guard refuses a
+// type-only default only when merged named specifiers exist. An empty named
+// list contributes none, so the bucket folds to the legal default-only form
+// `import type D from "m"` instead of falling back to two declarations.
+//
+//  1. Parse a type-only default import and an empty type-only named import
+//     of the same module.
+//  2. Apply the rule with default options.
+//  3. Assert one merged default-only `import type` declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification Type-default D plus empty type-named import must collapse to legal default-only type D from m.
+// @evidence contracts/testing.md#independent-expectations Official TypeScript restricts default-plus-named type imports; an empty list contributes no binding. The literal default-only result independently retains D and type erasure.
+// @evidence contracts/testing.md#distinguishing-cases Empty named contribution permits a merge, contrasting the nonempty A protection peers in both combine modes. Runtime-empty named imports have their own no-binding preservation host.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsMergesTypeDefaultWithEmptyNamed owns the authored empty-named/type-default boundary snapshot in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsMergesTypeDefaultWithEmptyNamed(t *testing.T) {
+  source := "import type D from \"m\";\n" +
+    "import type {} from \"m\";\n"
+  expected := "import type D from \"m\";\n"
+  assertFixSnapshot(t, "format/sort-imports", source, expected)
+}

package/linthost/format_sort_imports_merges_type_named_binding_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsMergesTypeNamedBinding pins the AST-flag classification in
+// collectMergedSpecs against a binding literally named `type`.
+//
+// `import type { type as bar }` imports the export named `type` (aliased `bar`),
+// type-only. The specifier carries NO inline `type` modifier (TS forbids one inside
+// `import type { … }`), so its own AST flag is false; the type-only-ness comes from
+// the declaration. A `"type "` string-prefix check would see the specifier text
+// `type as bar`, conclude it is already an inline type specifier, and skip adding
+// the modifier when folding into a mixed value import, silently demoting `bar` to a
+// value import. Classifying by the AST flag keeps the modifier, so the merged form
+// stays type-only for that binding: `type type as bar` (inline `type`, name `type`,
+// alias `bar`).
+//
+// 1. Parse value foo plus a type-only export literally named type and aliased bar.
+// 2. Enable both combining and unsafe runtime sorting.
+// 3. Assert the complete output preserves foo as value and bar as inline type.
+//
+// @evidence contracts/testing.md#behavioral-verification Merging must keep foo a value and bar type-only as type type as bar, retaining its imported export name type and local alias bar.
+// @evidence contracts/testing.md#independent-expectations TypeScript inline-type syntax separates the modifier from an export literally named type. The authored exact output independently preserves both roles and foo use under the documented combine policy.
+// @evidence contracts/testing.md#distinguishing-cases The imported name starts with type but has no inline modifier in its type-only declaration. The ordinary Bar combine peer distinguishes this contextual-keyword spelling.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsMergesTypeNamedBinding owns the literal contextual-keyword alias transformation with both supported options in the selected public Go unit population. The owning syntax rule and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsMergesTypeNamedBinding(t *testing.T) {
+  source := "import { foo } from \"m\";\n" +
+    "import type { type as bar } from \"m\";\n" +
+    "foo;\n"
+  expected := "import { foo, type type as bar } from \"m\";\n" +
+    "foo;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"combineTypeAndValue":true,"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_orders_case_insensitively_by_default_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsOrdersCaseInsensitivelyByDefault verifies module
+// specifiers sort case-insensitively unless caseSensitive is set.
+//
+// `apple` and `React` interleave only under a case-folded comparison; the
+// default lowercases both before comparing, so `apple` precedes `React`.
+//
+//  1. Parse imports of `React` and `apple`.
+//  2. Enable unsafe runtime sorting with the default comparison mode.
+//  3. Assert `apple` sorts before `React`.
+//
+// @evidence contracts/testing.md#behavioral-verification Unsafe sorting with default comparison must put apple before React while preserving case in each module/binding and all original use bytes.
+// @evidence contracts/testing.md#independent-expectations The documented case-insensitive default orders the literal apple key before react. Authored complete output keeps original spelling rather than regenerating strings from the sorter.
+// @evidence contracts/testing.md#distinguishing-cases Uppercase React and lowercase apple reverse order under raw comparison; the case-sensitive twin asserts that alternate option. Both use explicit runtime permission.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsOrdersCaseInsensitivelyByDefault owns the authored mixed-case complete-output transformation and default comparison option in the selected public Go unit population. Owning syntax rule and fixture edits execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsOrdersCaseInsensitivelyByDefault(t *testing.T) {
+  source := "import React from \"React\";\n" +
+    "import apple from \"apple\";\n" +
+    "React;\n" +
+    "apple;\n"
+  expected := "import apple from \"apple\";\n" +
+    "import React from \"React\";\n" +
+    "React;\n" +
+    "apple;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_orders_case_sensitively_when_enabled_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsOrdersCaseSensitivelyWhenEnabled verifies caseSensitive
+// switches to raw ASCII ordering (uppercase before lowercase).
+//
+// Under ASCII order `React` (R=0x52) precedes `apple` (a=0x61), the opposite of
+// the case-insensitive default, isolating the caseSensitive branch.
+//
+//  1. Parse imports of `apple` and `React`.
+//  2. Enable caseSensitive and unsafe runtime sorting.
+//  3. Assert `React` sorts before `apple`.
+//
+// @evidence contracts/testing.md#behavioral-verification Explicit case-sensitive unsafe sorting must put React before apple and preserve all module, binding and use spelling.
+// @evidence contracts/testing.md#independent-expectations The public caseSensitive option uses raw ordering; R precedes a in ASCII. The authored literal output independently fixes that order without case-folding the preserved payload.
+// @evidence contracts/testing.md#distinguishing-cases The same mixed-case pair appears with reversed expectation in the default-comparison twin. This positive isolates the option from runtime permission, which is also explicitly enabled.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsOrdersCaseSensitivelyWhenEnabled owns the authored mixed-case complete-output transformation with both explicit options in the selected public Go unit population. Owning syntax rule and fixture edits execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatSortImportsOrdersCaseSensitivelyWhenEnabled(t *testing.T) {
+  source := "import apple from \"apple\";\n" +
+    "import React from \"React\";\n" +
+    "React;\n" +
+    "apple;\n"
+  expected := "import React from \"React\";\n" +
+    "import apple from \"apple\";\n" +
+    "React;\n" +
+    "apple;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"caseSensitive":true,"unsafeSortRuntimeImports":true}`, expected)
+}