@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_semi_terminates_a_member_across_crlf_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesAMemberAcrossCrlf verifies the member insert
+// recognizes a CRLF break, so a CRLF interface is terminated exactly like
+// an LF one.
+//
+// The insert fires only when a line break separates the member from the
+// next significant byte. This input contains both CR and LF, so ignoring
+// only CR while still recognizing LF would not change its insertion.
+// It verifies CRLF pair handling, not the bare-CR branch independently.
+// The `\r\n` bytes must also survive the edit, which is zero-width and so
+// never rewrites them.
+//
+//  1. Parse a CRLF interface whose member carries no terminator.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert the `;` is inserted and the CRLF endings are preserved.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must recognize a CRLF-broken interface member and insert its semicolon without rewriting line-ending bytes or the string annotation.
+// @evidence contracts/testing.md#independent-expectations The complete escaped output literal independently specifies the same CRLF source with one appended member terminator.
+// @evidence contracts/testing.md#distinguishing-cases This changed CRLF single-member positive complements LF broken-interface insertion and one-line bare-member negatives.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesAMemberAcrossCrlf is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning semicolon rule and applies edits for complete literal output comparison in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatSemiTerminatesAMemberAcrossCrlf(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "interface Shape {\r\n  value: string\r\n}\r\n",
+    "interface Shape {\r\n  value: string;\r\n}\r\n",
+  )
+}

package/linthost/format_semi_terminates_a_member_whose_type_ends_in_a_brace_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesAMemberWhoseTypeEndsInABrace verifies a member
+// whose TYPE is a broken object literal is still terminated.
+//
+// It is the twin that separates the two ways a member can end in `}`. A
+// class accessor with a body ends in the `}` of that body and Prettier
+// never follows it with `;`, so the abstention has to key on the member
+// carrying a body, not on its last byte: a `src[end-1] == '}'` test would
+// read this member the same way and leave it bare. Prettier 3.8.3 closes
+// this one with `};`.
+//
+//  1. Parse an interface member whose nested type literal is broken across
+//     lines and whose own terminator is missing.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert the `;` lands after the nested closing brace.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must append the outer interface member terminator after its nested object-type brace while retaining the already-terminated inner property.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output preserves the nested type and distinguishes its closing type brace from an accessor body brace; the outer member still requires punctuation.
+// @evidence contracts/testing.md#distinguishing-cases The changed nested-type-ending-brace case complements braced-accessor no-insertion negatives, rejecting a last-byte-is-brace abstention heuristic.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesAMemberWhoseTypeEndsInABrace is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning semicolon rule and applies edits for exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiTerminatesAMemberWhoseTypeEndsInABrace(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "interface Outer {\n  nested: {\n    inner: number;\n  }\n}\n",
+    "interface Outer {\n  nested: {\n    inner: number;\n  };\n}\n",
+  )
+}

package/linthost/format_semi_terminates_broken_interface_members_test.go

@@ -0,0 +1,45 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesBrokenInterfaceMembers verifies the always
+// direction reaches every interface member kind, the last one included.
+//
+// The direct member insert path reaches all seven authored signature
+// spellings in this broken interface, including the last setter. The full
+// literal output specifies those edits; this entry does not execute body
+// splitting or establish an earlier rule failure.
+
+//  1. Parse an interface whose seven members are each on their own line
+//     with no terminator.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert every member gained a `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must append a semicolon to each of seven broken-interface member spellings while preserving every signature and property annotation.
+// @evidence contracts/testing.md#independent-expectations The literal full output independently lists the required terminators for property, method, index, call, construct and get/set signatures under default semi policy.
+// @evidence contracts/testing.md#distinguishing-cases All seven local member shapes, including the last setter, require a change; flat-interface singleton/pair negatives and already-terminated member cases own adjacent no-op layouts.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesBrokenInterfaceMembers is a selected public Go unit under the lint semantic-unit Evidence claim. The shared syntax-only fixture harness calls the owning semicolon rule and applies edits for the complete literal output assertion in the same Go process without a consumer install, native product build or product host.
+func TestFormatSemiTerminatesBrokenInterfaceMembers(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "interface Shape {\n"+
+      "  value: string\n"+
+      "  method(): void\n"+
+      "  [key: string]: string\n"+
+      "  (): void\n"+
+      "  new (): Shape\n"+
+      "  get first(): string\n"+
+      "  set first(next: string)\n"+
+      "}\n",
+    "interface Shape {\n"+
+      "  value: string;\n"+
+      "  method(): void;\n"+
+      "  [key: string]: string;\n"+
+      "  (): void;\n"+
+      "  new (): Shape;\n"+
+      "  get first(): string;\n"+
+      "  set first(next: string);\n"+
+      "}\n",
+  )
+}

package/linthost/format_semi_terminates_broken_type_literal_member_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesBrokenTypeLiteralMember verifies a type literal
+// written across lines takes the terminator while an inline one does not.
+//
+// Prettier preserves an object type's authored wrap: a literal whose `{`
+// is followed by a line break stays broken and terminates its members,
+// and one written inline stays inline and leaves its last member bare.
+// The direct insert checks both a break after the member and the type
+// list's opening-brace wrap before a final-member insertion. These two
+// fixtures distinguish broken and inline inputs; half-wrapped companions
+// own the independent opening-versus-closing boundary distinction.
+//
+//  1. Parse a broken type literal and an inline one.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert only the broken literal's member gains a `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must terminate the broken type-literal member while leaving the same annotated member in an inline literal bare.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output expresses layout-dependent trailing termination and preserves both string-typed properties and alias terminators.
+// @evidence contracts/testing.md#distinguishing-cases Broken and inline singleton type bodies share one fixture as changed/unchanged twins; the half-wrapped mapped-type case owns the related opening-brace decision separately.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesBrokenTypeLiteralMember is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning semicolon rule and applies edits for complete literal output comparison in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatSemiTerminatesBrokenTypeLiteralMember(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type Broken = {\n  name: string\n};\ntype Inline = { name: string };\n",
+    "type Broken = {\n  name: string;\n};\ntype Inline = { name: string };\n",
+  )
+}

package/linthost/format_semi_terminates_class_index_signature_and_ambient_accessor_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesClassIndexSignatureAndAmbientAccessor verifies the
+// class-body spellings of the member kinds take the same terminator.
+//
+// An index signature and a bodiless `declare` accessor are class members
+// written as type members. Both are already on their own lines in this
+// fixture, and the direct semicolon path terminates both. No indent rule
+// or interface failure reproduction runs in this entry.
+//
+//  1. Parse a class with an index signature and an ambient class with a
+//     bodiless getter, each unterminated on its own line.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert both members gain a `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must append terminators to a class index signature and a bodiless ambient getter while preserving their string annotations and declarations.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output gives each broken type-shaped class member its required terminator; neither fixture has a braced accessor body.
+// @evidence contracts/testing.md#distinguishing-cases The index signature and ambient getter positives complement interface signature insertion and class/object braced-getter negatives, distinguishing member shape from shared kind.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesClassIndexSignatureAndAmbientAccessor is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning semicolon rule and applies edits for exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiTerminatesClassIndexSignatureAndAmbientAccessor(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "class Value {\n  [key: string]: string\n}\ndeclare class Ambient {\n  get first(): string\n}\n",
+    "class Value {\n  [key: string]: string;\n}\ndeclare class Ambient {\n  get first(): string;\n}\n",
+  )
+}

package/linthost/format_sort_imports_alphabetizes_named_specifiers_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsAlphabetizesNamedSpecifiers verifies the
+// specifier-level pass reorders `{ b, a }` into `{ a, b }`.
+//
+// Specifier sorting is the in-import portion of the rule's contract. The
+// block-level pass leaves untouched imports already in canonical order, so
+// the specifier pass exists to keep diffs small inside a single import
+// statement. This scenario isolates that pass: one import declaration, no
+// block-level reorder.
+//
+// 1. Parse a source file with one import whose specifiers are out of order.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file has the specifiers in alphabetical order.
+// 4. Distinguish imported names from local aliases and assert the sorted twin stays silent.
+//
+// @evidence contracts/testing.md#behavioral-verification The fs read/write list must reorder without changing module or uses. Aliased names must sort by local a/z while preserving their imported names, and that authored canonical alias list must emit no findings.
+// @evidence contracts/testing.md#independent-expectations Supported named-import sorting uses accessible local binding names. Literal outputs independently order read before write and a before z while retaining export-to-local mappings and body bytes.
+// @evidence contracts/testing.md#distinguishing-cases One declaration isolates local specifier sorting from runtime block rewriting. The alias fixture has export order opposite local order, and its sorted twin is negative; comment-bearing lists belong to a separate protection host.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsAlphabetizesNamedSpecifiers owns the original fs snapshot, authored alias transformation and canonical alias negative in the selected public Go unit population. Syntax-only owning rule and fixture edits execute in one Go process without native builds, consumer installation or product-host children.
+func TestFormatSortImportsAlphabetizesNamedSpecifiers(t *testing.T) {
+  source := "import { writeFileSync, readFileSync } from \"node:fs\";\n" +
+    "readFileSync; writeFileSync;\n"
+  expected := "import { readFileSync, writeFileSync } from \"node:fs\";\n" +
+    "readFileSync; writeFileSync;\n"
+  assertFixSnapshot(t, "format/sort-imports", source, expected)
+  assertFixSnapshot(t, "format/sort-imports", "import { a as z, z as a } from \"m\";\nconsole.log(a, z);\n", "import { z as a, a as z } from \"m\";\nconsole.log(a, z);\n")
+  assertRuleSkipsSource(t, "format/sort-imports", "import { z as a, a as z } from \"m\";\nconsole.log(a, z);\n")
+}

package/linthost/format_sort_imports_combine_requires_unsafe_runtime_opt_in_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsCombineRequiresUnsafeRuntimeOptIn verifies
+// combineTypeAndValue alone cannot rewrite a runtime-bearing import block.
+//
+// Combining declarations uses the same whole-block rebuilder as grouping and
+// sorting. Letting the apparently narrow option bypass the runtime guard would
+// reintroduce declaration reordering through a less obvious configuration path.
+//
+//  1. Parse same-module value and type-only declarations.
+//  2. Enable combineTypeAndValue without unsafeSortRuntimeImports.
+//  3. Assert the mixed block remains byte-for-byte unchanged.
+//
+// @evidence contracts/testing.md#behavioral-verification Enabling combineTypeAndValue alone must emit no findings for value plus type-only imports of m, preserving the value use.
+// @evidence contracts/testing.md#independent-expectations The public option contract requires explicit unsafeSortRuntimeImports before mixed runtime declarations may be rewritten. Zero findings independently enforces that permission boundary.
+// @evidence contracts/testing.md#distinguishing-cases Same-module value/type imports are merge-compatible but lack runtime opt-in; the combines-type-and-value host supplies the adjacent both-options positive.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsCombineRequiresUnsafeRuntimeOptIn owns the literal mixed-block no-finding input and explicit combine-only 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 TestFormatSortImportsCombineRequiresUnsafeRuntimeOptIn(t *testing.T) {
+  source := "import { value } from \"m\";\n" +
+    "import type { Value } from \"m\";\n" +
+    "value;\n"
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/sort-imports",
+    source,
+    `{"combineTypeAndValue":true}`,
+  )
+}

package/linthost/format_sort_imports_combines_type_and_value_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsCombinesTypeAndValue verifies combineTypeAndValue folds
+// a type-only import into a value import of the same module.
+//
+// With the option on, the type-only specifiers move into the value declaration
+// as inline `type` specifiers (ordered after the value specifiers); the merged
+// declaration is no longer type-only.
+//
+//  1. Parse a value import and a type-only import of the same module.
+//  2. Enable combineTypeAndValue and unsafe runtime sorting.
+//  3. Assert one declaration with the value specifier before the inline `type`.
+//
+// @evidence contracts/testing.md#behavioral-verification Both enabled options must merge foo and type-only Bar into one foo,type Bar import while retaining foo use.
+// @evidence contracts/testing.md#independent-expectations The public combine contract preserves Bar as an inline type import and foo as a value binding. The complete literal output fixes that distinction independently of bucket construction.
+// @evidence contracts/testing.md#distinguishing-cases Both options are enabled, contrasting combine-only abstention and unsafe-without-combine separation. Type-only default protection is owned by separate hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsCombinesTypeAndValue owns the literal mixed-type/value transformation and both explicit 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 TestFormatSortImportsCombinesTypeAndValue(t *testing.T) {
+  source := "import { foo } from \"m\";\n" +
+    "import type { Bar } from \"m\";\n" +
+    "foo;\n"
+  expected := "import { foo, type Bar } from \"m\";\n" +
+    "foo;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"combineTypeAndValue":true,"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_dedupes_repeated_specifier_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsDedupesRepeatedSpecifier verifies merging duplicate
+// modules collapses a specifier imported twice into a single entry.
+//
+// The merge step de-duplicates named specifiers by their local binding name, so two
+// declarations each importing `{ a }` yield one `{ a }`.
+//
+//  1. Parse two imports of `{ a }` from the same module.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the merged declaration lists `a` once.
+//  4. Assert distinct aliases of the same export both survive the merged output.
+//
+// @evidence contracts/testing.md#behavioral-verification Duplicate a imports must collapse to one a binding while preserving its use; two imports of the same export with distinct left/right aliases must retain both local bindings.
+// @evidence contracts/testing.md#independent-expectations The literal outputs follow the supported unsafe same-module merge contract and TypeScript local binding identity. Distinct aliases denote two accessible names even when they read the same exported value.
+// @evidence contracts/testing.md#distinguishing-cases Repeated local a is the normalization positive, while same export a with different local aliases must survive as two specifiers. Default-mode runtime preservation and conflicting-default hosts supply separate safety boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsDedupesRepeatedSpecifier owns the original duplicate-binding parse input and its full-output oracle plus the distinct-alias transformation in the public Go unit population. Owning syntax rule and fixture fixer run in one Go process without installation, native builds or real product-host children.
+func TestFormatSortImportsDedupesRepeatedSpecifier(t *testing.T) {
+  source := "import { a } from \"m\";\n" +
+    "import { a } from \"m\";\n" +
+    "a;\n"
+  expected := "import { a } from \"m\";\n" +
+    "a;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import { a as right } from \"m\";\nimport { a as left } from \"m\";\nconsole.log(left, right);\n", `{"unsafeSortRuntimeImports":true}`, "import { a as left, a as right } from \"m\";\nconsole.log(left, right);\n")
+}

package/linthost/format_sort_imports_group_separator_honors_crlf_end_of_line_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsGroupSeparatorHonorsCRLFEndOfLine verifies the blank
+// line between import groups is two CRLF terminators under endOfLine:"crlf".
+//
+// The expected blank group separator contains two CRLF pairs; emitting
+// a hard-coded "\n\n" instead would introduce two lone LFs. The LF twin is
+// format_sort_imports_separator_spans_empty_group_test.go. The helper asserts
+// zero lone LFs, which specifically pins that BOTH newlines of the blank line
+// are "\r\n".
+//
+//  1. Parse a CRLF file with one third-party and one relative import.
+//  2. Apply an order that separates the two populated groups with a blank line
+//     under {"endOfLine":"crlf"}.
+//  3. Assert the blank line is "\r\n\r\n" and no lone LF remains.
+//
+// @evidence contracts/testing.md#behavioral-verification The alpha and relative imports must gain exactly a CRLF/CRLF blank separator, preserve all uses and contain no lone LF.
+// @evidence contracts/testing.md#independent-expectations The explicit crlf option requires each synthesized group line ending to be CRLF. The literal full-output and independent lone-LF check distinguish mixed-ending corruption.
+// @evidence contracts/testing.md#distinguishing-cases The middle api group is empty but its separator still applies. The LF empty-group twin and ordinary CRLF join host distinguish separator and declaration joins.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsGroupSeparatorHonorsCRLFEndOfLine owns the authored CRLF group-separator fixture, complete output and lone-LF assertion 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 TestFormatSortImportsGroupSeparatorHonorsCRLFEndOfLine(t *testing.T) {
+  source := "import { a } from \"alpha\";\r\n" +
+    "import { b } from \"./local\";\r\n" +
+    "a;\r\n" +
+    "b;\r\n"
+  expected := "import { a } from \"alpha\";\r\n" +
+    "\r\n" +
+    "import { b } from \"./local\";\r\n" +
+    "a;\r\n" +
+    "b;\r\n"
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/sort-imports",
+    source,
+    `{"order":["<THIRD_PARTY_MODULES>","","@api/(.*)","","^[.]"],"unsafeSortRuntimeImports":true,"endOfLine":"crlf"}`,
+    expected,
+  )
+}

package/linthost/format_sort_imports_groups_builtins_first_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsGroupsBuiltinsFirst verifies the <BUILTIN_MODULES> group
+// hoists Node built-in imports above third-party and relative imports.
+//
+// The default order leads with <BUILTIN_MODULES>; a `node:`-prefixed or bare
+// built-in specifier must land there ahead of everything else.
+//
+//  1. Parse a file mixing a built-in, a third-party, and a relative import.
+//  2. Apply the rule with unsafe runtime sorting enabled.
+//  3. Assert the built-in import sits first.
+//
+// @evidence contracts/testing.md#behavioral-verification Unsafe default grouping must put node:fs before express and local, preserving the imported bindings and their object use.
+// @evidence contracts/testing.md#independent-expectations The public default order puts Node built-ins before third-party and relative imports. The literal output independently identifies fs as built-in and preserves every binding/use.
+// @evidence contracts/testing.md#distinguishing-cases The tested built-in spelling is node:fs; third-party express and relative local supply distinct group members. External-before-relative and custom-order hosts supply other group boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsGroupsBuiltinsFirst owns the literal three-group node:fs transformation and unsafe 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 TestFormatSortImportsGroupsBuiltinsFirst(t *testing.T) {
+  source := "import { x } from \"./local\";\n" +
+    "import express from \"express\";\n" +
+    "import { readFile } from \"node:fs\";\n" +
+    "JSON.stringify({ x, express, readFile });\n"
+  expected := "import { readFile } from \"node:fs\";\n" +
+    "import express from \"express\";\n" +
+    "import { x } from \"./local\";\n" +
+    "JSON.stringify({ x, express, readFile });\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_groups_external_before_relative_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsGroupsExternalBeforeRelative verifies the canonical
+// group order: third-party modules sit above relative-path imports.
+//
+// The group split is the rule's load-bearing contract; without it the
+// formatter is just an alphabetizer that ignores the most useful axis. This
+// scenario pins the default group order and the alphabetical sort within each
+// group. The default order carries no "" separator, so the groups are adjacent
+// (blank lines are opt-in by position).
+//
+//  1. Parse a source file with mixed third-party and relative imports in
+//     intentionally shuffled order.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file matches the canonical layout.
+//
+// @evidence contracts/testing.md#behavioral-verification Unsafe default ordering must produce alpha,zebra,local-a,local-b without blank separators and with the complete use unchanged.
+// @evidence contracts/testing.md#independent-expectations The documented default third-party-before-relative order and alphabetical ordering yield the authored literal sequence. No empty-string order entry means no group blank line.
+// @evidence contracts/testing.md#distinguishing-cases Two populated groups each contain two shuffled imports, unlike the builtin-first three-group host and explicit-separator hosts. Default safe runtime preservation belongs to separate hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsGroupsExternalBeforeRelative owns the authored four-import complete-output fixture and explicit unsafe permission 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 TestFormatSortImportsGroupsExternalBeforeRelative(t *testing.T) {
+  source := "import { reduce } from \"./local-b\";\n" +
+    "import zebra from \"zebra\";\n" +
+    "import { x } from \"./local-a\";\n" +
+    "import alpha from \"alpha\";\n" +
+    "JSON.stringify({ reduce, zebra, x, alpha });\n"
+  expected := "import alpha from \"alpha\";\n" +
+    "import zebra from \"zebra\";\n" +
+    "import { x } from \"./local-a\";\n" +
+    "import { reduce } from \"./local-b\";\n" +
+    "JSON.stringify({ reduce, zebra, x, alpha });\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_groups_type_only_imports_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsGroupsTypeOnlyImports verifies a <TYPES> group hoists
+// `import type` declarations ahead of value imports.
+//
+// The placeholder matches type-only declarations regardless of specifier, so a
+// `<TYPES>` group placed first pulls every `import type` to the top.
+//
+//  1. Parse a value import and a type-only import.
+//  2. Apply that order with unsafe runtime sorting enabled.
+//  3. Assert the type-only import sorts first.
+//
+// @evidence contracts/testing.md#behavioral-verification An explicit leading TYPES group must move type-only B from n ahead of value a from m without combining them or changing a use.
+// @evidence contracts/testing.md#independent-expectations The supported TYPES placeholder matches clause-level type-only imports regardless of module spelling. The literal output independently preserves the type/value phases and declared group order.
+// @evidence contracts/testing.md#distinguishing-cases Both type and value groups are populated with different modules. The regex-scoped TYPES host supplies matched and unmatched type imports; inline-type runtime protection is separate.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsGroupsTypeOnlyImports owns the literal mixed-phase custom-group transformation and unsafe permission 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 TestFormatSortImportsGroupsTypeOnlyImports(t *testing.T) {
+  source := "import { a } from \"m\";\n" +
+    "import type { B } from \"n\";\n" +
+    "a;\n"
+  expected := "import type { B } from \"n\";\n" +
+    "import { a } from \"m\";\n" +
+    "a;\n"
+  assertFixSnapshotWithOptions(t, "format/sort-imports", source, `{"order":["<TYPES>","<THIRD_PARTY_MODULES>"],"unsafeSortRuntimeImports":true}`, expected)
+}

package/linthost/format_sort_imports_honors_crlf_end_of_line_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsHonorsCRLFEndOfLine verifies the rebuilt import block
+// joins declarations with CRLF under endOfLine:"crlf".
+//
+// This entry supplies endOfLine directly to the rule options and fixes
+// the complete CRLF output independently. A hard-coded LF join would fail
+// both that literal and the helper's zero-lone-LF assertion. The LF twin is
+// format_sort_imports_groups_external_before_relative_test.go; this host
+// does not authenticate top-level option threading or historical failures.
+
+//  1. Parse a CRLF file with shuffled third-party and relative imports.
+//  2. Apply format/sort-imports with {"endOfLine":"crlf"}.
+//  3. Assert the declarations join with "\r\n" and no lone LF remains.
+//
+// @evidence contracts/testing.md#behavioral-verification Sorting must retain CRLF in all rebuilt joins and the unchanged body while producing alpha,zebra,local-a,local-b with zero lone LF.
+// @evidence contracts/testing.md#independent-expectations The explicit crlf option requires synthesized declaration joins to use CRLF. Whole-file literal order and lone-LF scanning independently detect content and line-ending errors.
+// @evidence contracts/testing.md#distinguishing-cases Four shuffled imports occupy two adjacent groups without blank separators. The CRLF group-separator peer verifies the separate two-ending join and the LF twin owns default joins.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsHonorsCRLFEndOfLine owns the authored CRLF four-import snapshot and independent lone-LF observation 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 TestFormatSortImportsHonorsCRLFEndOfLine(t *testing.T) {
+  source := "import { reduce } from \"./local-b\";\r\n" +
+    "import zebra from \"zebra\";\r\n" +
+    "import { x } from \"./local-a\";\r\n" +
+    "import alpha from \"alpha\";\r\n" +
+    "JSON.stringify({ reduce, zebra, x, alpha });\r\n"
+  expected := "import alpha from \"alpha\";\r\n" +
+    "import zebra from \"zebra\";\r\n" +
+    "import { x } from \"./local-a\";\r\n" +
+    "import { reduce } from \"./local-b\";\r\n" +
+    "JSON.stringify({ reduce, zebra, x, alpha });\r\n"
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/sort-imports",
+    source,
+    `{"unsafeSortRuntimeImports":true,"endOfLine":"crlf"}`,
+    expected,
+  )
+}

package/linthost/format_sort_imports_honors_custom_import_order_test.go

@@ -0,0 +1,88 @@
+package linthost
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSortImportsHonorsCustomImportOrder verifies user-supplied `order`
+// regexes drive the group sequence and "" entries inject blank-line separators.
+//
+// The fixture has three import classes, `@api/*`, plain third-party, and
+// relative, in shuffled source order. With
+// `order: ["<THIRD_PARTY_MODULES>", "", "@api(.*)$", "", "^[./]"]` the expected
+// output is third-party first, then `@api/*`, then relative, with one blank
+// line between each group. This pins the custom-order + separator path through
+// the engine.
+//
+//  1. Parse a source file with mixed import classes.
+//  2. Apply the custom order and separators with unsafe runtime sorting.
+//  3. Assert the rewritten file has the imports laid out per the spec.
+//
+// @evidence contracts/testing.md#behavioral-verification Custom order must produce alpha, the api request, then local-a/local-b, with exactly two blank group separators and unchanged bindings/body. Applying and reparsing fixes must converge within the existing four-pass cap.
+// @evidence contracts/testing.md#independent-expectations The supported order array assigns third-party, api-regex and relative groups in that sequence. A separately authored whole-file literal pins both separators, within-relative order and all preserved use bytes.
+// @evidence contracts/testing.md#distinguishing-cases All three groups are populated here, contrasting the empty-middle-group separator host. Default group-order and CRLF hosts cover distinct options; the final zero-edit pass distinguishes oscillation.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsHonorsCustomImportOrder directly owns its literal source, InlineRuleResolver, engine/fixer/reparse loop and final complete-file assertion. These filesystem-backed owning functions execute in one Go process without consumer installation, native building or product-host children.
+func TestFormatSortImportsHonorsCustomImportOrder(t *testing.T) {
+  root := t.TempDir()
+  filePath := filepath.Join(root, "src", "main.ts")
+  source := "import { reduce } from \"./local-b\";\n" +
+    "import { request } from \"@api/http\";\n" +
+    "import alpha from \"alpha\";\n" +
+    "import { x } from \"./local-a\";\n" +
+    "JSON.stringify({ reduce, request, alpha, x });\n"
+  writeFile(t, filePath, source)
+  file := parseTSFile(t, filePath, source)
+
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/sort-imports": SeverityError},
+    Options: RuleOptionsMap{
+      "format/sort-imports": json.RawMessage(
+        `{"order":["<THIRD_PARTY_MODULES>","","@api(.*)$","","^[./]"],"unsafeSortRuntimeImports":true}`,
+      ),
+    },
+  }
+  // Apply and reparse each fix until a pass makes no changes.
+  const maxPasses = 4
+  converged := false
+  for pass := 0; pass < maxPasses; pass++ {
+    findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+    fixed, err := applyFindingFixes(root, findings)
+    if err != nil {
+      t.Fatalf("applyFindingFixes: %v", err)
+    }
+    if fixed == 0 {
+      converged = true
+      break
+    }
+    raw, err := os.ReadFile(filePath)
+    if err != nil {
+      t.Fatalf("ReadFile: %v", err)
+    }
+    file = parseTSFile(t, filePath, string(raw))
+  }
+  if !converged {
+    // A non-converged exit means the rule kept rewriting on every pass.
+    // Either the test fixture grew complexity the rule cannot settle, or
+    // the rule itself regressed into a re-emit loop. Either way we want a
+    // loud failure instead of a misleading green when the loop falls
+    // through with edits still pending.
+    t.Fatalf("formatSortImports did not converge within %d passes", maxPasses)
+  }
+  got, err := os.ReadFile(filePath)
+  if err != nil {
+    t.Fatalf("ReadFile: %v", err)
+  }
+  expected := "import alpha from \"alpha\";\n\n" +
+    "import { request } from \"@api/http\";\n\n" +
+    "import { x } from \"./local-a\";\n" +
+    "import { reduce } from \"./local-b\";\n" +
+    "JSON.stringify({ reduce, request, alpha, x });\n"
+  if string(got) != expected {
+    t.Fatalf("custom-order full output mismatch:\nwant:\n%s\ngot:\n%s", expected, got)
+  }
+}

package/linthost/format_sort_imports_keeps_attribute_bearing_imports_unmerged_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsAttributeBearingImportsUnmerged verifies protected declaration bytes
+// survive when runtime merging is otherwise permitted.
+//
+// Import attributes belong to their declaration. Explicit permission to reorder runtime imports must not allow a merge that deletes those bytes.
+//
+// 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 attributes and assert the full merged output.
+//
+// @evidence contracts/testing.md#behavioral-verification Both with-type-json clauses must remain separate with zero findings under default and explicit unsafe runtime modes.
+// @evidence contracts/testing.md#independent-expectations Literal import-attribute bytes belong to each dependency declaration. Removing them is a meaning-changing merge even when runtime reordering is permitted.
+// @evidence contracts/testing.md#distinguishing-cases Two same-module named imports carry attributes; the attribute-free twin must merge to import { a, b }, distinguishing attribute protection from the default runtime barrier.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsAttributeBearingImportsUnmerged owns its literal default/unsafe negatives and attribute-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 TestFormatSortImportsKeepsAttributeBearingImportsUnmerged(t *testing.T) {
+  assertRuleSkipsSource(t, "format/sort-imports", `import { a } from "x" with { type: "json" };
+import { b } from "x" with { type: "json" };
+`)
+  assertRuleSkipsSourceWithOptions(t, "format/sort-imports", "import { a } from \"x\" with { type: \"json\" };\nimport { b } from \"x\" with { type: \"json\" };\n", `{"unsafeSortRuntimeImports":true}`)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import { a } from \"x\";\nimport { b } from \"x\";\n", `{"unsafeSortRuntimeImports":true}`, "import { a, b } from \"x\";\n")
+}

package/linthost/format_sort_imports_keeps_commented_list_unmerged_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatSortImportsKeepsCommentedListUnmerged verifies protected declaration bytes
+// survive when runtime merging is otherwise permitted.
+//
+// A comment after the named binding must retain its declaration attachment. The unsafe negative exercises this protection, while removing only the comment permits merging.
+//
+// 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 a declaration must retain its interior keep comment and stay separate from b under default and unsafe modes.
+// @evidence contracts/testing.md#independent-expectations The authored comment and binding bytes are user input; literal zero-finding and comment-free complete-output expectations follow the documented comment-preservation and same-module merge policy.
+// @evidence contracts/testing.md#distinguishing-cases The comment occurs after the only named specifier. Removing only that comment supplies a merge positive; unsafe opt-in ensures the negative reaches merge eligibility.
+// @evidence contracts/testing.md#execution-ownership TestFormatSortImportsKeepsCommentedListUnmerged 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 TestFormatSortImportsKeepsCommentedListUnmerged(t *testing.T) {
+  source := "import { a /* keep */ } from \"m\";\n" +
+    "import { b } from \"m\";\n" +
+    "a;\n" +
+    "b;\n"
+  assertRuleSkipsSource(t, "format/sort-imports", source)
+  assertRuleSkipsSourceWithOptions(t, "format/sort-imports", source, `{"unsafeSortRuntimeImports":true}`)
+  assertFixSnapshotWithOptions(t, "format/sort-imports", "import { a } from \"m\";\nimport { b } from \"m\";\na;\nb;\n", `{"unsafeSortRuntimeImports":true}`, "import { a, b } from \"m\";\na;\nb;\n")
+}