@ttsc/lint 0.30.4 → 0.31.1

package/linthost/format_brace_continuation_pushes_else_off_a_statement_consequent_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatBraceContinuationPushesElseOffAStatementConsequent verifies `else` starts its own line when the consequent is not a block.
+//
+// This exercises the non-block direction of the same gap operation. The full
+// expected source requires a newline before `else`, in contrast to the block
+// consequent's one-space target; it does not prescribe how many rules a
+// different formatter architecture must use.
+//
+//  1. Parse a one-line `if`/`else` with a statement consequent.
+//  2. Apply format/brace-continuation.
+//  3. Assert `else` moves to its own line at the statement's indent.
+//
+// @evidence contracts/testing.md#behavioral-verification format/brace-continuation must give else its own line after the non-block x call consequent.
+// @evidence contracts/testing.md#independent-expectations The complete literal output preserves condition a and x/y calls and replaces only the gap before else with the supported top-level newline.
+// @evidence contracts/testing.md#distinguishing-cases This non-block else positive complements block-else pull-up and split canonical abstention; nested and wrong-column cases additionally distinguish owning indentation.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationPushesElseOffAStatementConsequent is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the source and independent literal output; the shared syntax-only harness invokes the rule and applies its edits in process without a consumer install, native product build or product host.
+func TestFormatBraceContinuationPushesElseOffAStatementConsequent(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/brace-continuation",
+    "if (a) x(); else y();\n",
+    `{"tabWidth":2}`,
+    "if (a) x();\nelse y();\n",
+  )
+}

package/linthost/format_brace_continuation_pushes_past_a_brace_terminated_non_block_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatBraceContinuationPushesPastABraceTerminatedNonBlock verifies a consequent that ends in a brace but is not a block still pushes down.
+//
+// A `switch` consequent has the same final `}` byte as a block but a different
+// AST kind. The full expected source requires a newline before `else`, so
+// always joining after a closing-brace byte cannot satisfy this case and the
+// block-consequent companion together.
+//
+//  1. Parse an `if` whose consequent is a `switch` statement, with `else` inline.
+//  2. Apply format/brace-continuation.
+//  3. Assert `else` moves to its own line rather than onto the closing brace.
+//
+// @evidence contracts/testing.md#behavioral-verification format/brace-continuation must push else after a switch consequent even though that non-block statement ends with a closing brace.
+// @evidence contracts/testing.md#independent-expectations The complete literal output retains both conditions, the empty switch body and y call; the supported clause-kind policy puts else on its own line rather than treating every closing-brace byte as a Block.
+// @evidence contracts/testing.md#distinguishing-cases This brace-terminated SwitchStatement positive is the adjacent kind counterexample to block-else pull-up, preventing a last-byte heuristic from passing both.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationPushesPastABraceTerminatedNonBlock is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the source and independent literal output; the shared syntax-only harness invokes the rule and applies its edits in process without a consumer install, native product build or product host.
+func TestFormatBraceContinuationPushesPastABraceTerminatedNonBlock(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/brace-continuation",
+    "if (a) switch (b) {\n} else y();\n",
+    `{"tabWidth":2}`,
+    "if (a) switch (b) {\n}\nelse y();\n",
+  )
+}

package/linthost/format_brace_continuation_pushes_past_a_label_prefix_test.go

@@ -0,0 +1,48 @@
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestFormatBraceContinuationPushesPastALabelPrefix verifies a labeled statement
+// still pushes its continuation keyword down.
+//
+// The abstention for a statement that does not own its line is what keeps a
+// keyword from landing at column zero. The supported ASCII `outer:` prefix
+// belongs to the labeled statement; the helper accepts that label run when
+// locating its owning indentation. This command fixture requires the label to
+// remain on the if line and observes the completed cascade for this input,
+// without a claim about every label or every hypothetical deferred pass.
+//
+//  1. Seed a project with a labeled one-line `if`/`else` inside a function.
+//  2. Run `ttsc format`.
+//  3. Assert `else` lands on its own line at the statement's column.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must complete the cascade for a labeled if/else and place else at the two-space column while retaining outer: on the if line.
+// @evidence contracts/testing.md#independent-expectations The fixed full-file literal preserves the label, function, condition and calls; zero exit code and empty stdout/stderr independently require a successful quiet command as well as correct disk content.
+// @evidence contracts/testing.md#distinguishing-cases This labeled-prefix command positive distinguishes a label belonging to the same statement from a preceding statement requiring deferral; the shared-line cascade and direct abstention cases own that neighboring decision.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationPushesPastALabelPrefix is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the seeded project/config fixtures and all exit, stream and full disk-output assertions. It calls the real formatter command and cascade in the same Go process; no consumer install, native product build or product host is started.
+func TestFormatBraceContinuationPushesPastALabelPrefix(t *testing.T) {
+  root := seedLintProject(t, "function f() {\n  outer: if (a) x(); else y();\n}\n")
+  seedLintConfig(t, root, map[string]any{"format": map[string]any{}})
+  code, stdout, stderr := captureCommandOutput(t, func() int {
+    return run([]string{
+      "format",
+      "--cwd", root,
+      "--plugins-json", lintManifest(t),
+    })
+  })
+  if code != 0 || stdout != "" || stderr != "" {
+    t.Fatalf("format command mismatch: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+  }
+  got, err := os.ReadFile(filepath.Join(root, "src", "main.ts"))
+  if err != nil {
+    t.Fatalf("ReadFile: %v", err)
+  }
+  want := "function f() {\n  outer: if (a) x();\n  else y();\n}\n"
+  if string(got) != want {
+    t.Fatalf("formatted source mismatch:\nwant %q\ngot  %q", want, string(got))
+  }
+}

package/linthost/format_brace_continuation_settles_a_shared_line_through_the_cascade_test.go

@@ -0,0 +1,44 @@
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestFormatBraceContinuationSettlesASharedLineThroughTheCascade verifies the command resolves a shared line at the enclosing column.
+//
+// The single-rule companion requires abstention while `if` shares a line with
+// `foo`. This command-level case requires the complete final output to contain
+// separate statements and the enclosing indentation. It does not observe
+// intermediate passes or attribute each change to a particular rule.
+//
+//  1. Seed a project whose `if`/`else` shares a line with a preceding statement.
+//  2. Run `ttsc format`.
+//  3. Assert `else` lands at the enclosing body's column, not at zero.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must finish with foo on its own line and if/else at the enclosing two-space column.
+// @evidence contracts/testing.md#independent-expectations The complete disk-output literal preserves function f and calls foo/x/y and condition a; exact successful status and empty streams require the actual command path to finish as well as write that output.
+// @evidence contracts/testing.md#distinguishing-cases This command-output positive complements the single-rule shared-line negative, requiring the final split and placement without certifying intermediate pass order. The labeled-prefix command positive distinguishes a prefix that must remain attached.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationSettlesASharedLineThroughTheCascade is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns the seeded project/config fixtures and all exit, stream and full disk-output assertions. It calls the real formatter command and cascade in the same Go process; no consumer install, native product build or product host is started.
+func TestFormatBraceContinuationSettlesASharedLineThroughTheCascade(t *testing.T) {
+  root := seedLintProject(t, "function f() {\n  foo(); if (a) x(); else y();\n}\n")
+  seedLintConfig(t, root, map[string]any{"format": map[string]any{}})
+  code, stdout, stderr := captureCommandOutput(t, func() int {
+    return run([]string{
+      "format",
+      "--cwd", root,
+      "--plugins-json", lintManifest(t),
+    })
+  })
+  if code != 0 || stdout != "" || stderr != "" {
+    t.Fatalf("format command mismatch: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+  }
+  got, err := os.ReadFile(filepath.Join(root, "src", "main.ts"))
+  if err != nil {
+    t.Fatalf("ReadFile: %v", err)
+  }
+  if want := "function f() {\n  foo();\n  if (a) x();\n  else y();\n}\n"; string(got) != want {
+    t.Fatalf("formatted source mismatch:\nwant %q\ngot  %q", want, string(got))
+  }
+}

package/linthost/format_brace_continuation_skips_a_commented_gap_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatBraceContinuationSkipsACommentedGap verifies a comment between a clause and its keyword blocks the move.
+//
+// The gap rewrite would delete the comment. The rule detects it by requiring the
+// first non-whitespace byte after the clause to be the keyword itself, so a
+// comment fails the match instead of being swallowed. The assertions cover this
+// rule's refusal, not the complete output of another formatter.
+//
+//  1. Parse line-comment and block-comment gaps between the brace and `else`.
+//  2. Run format/brace-continuation.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/brace-continuation must report no finding when either a line or block comment occupies the gap between a block and else.
+// @evidence contracts/testing.md#independent-expectations The literal comments are source content rather than removable gap whitespace; zero findings prevents their deletion or relocation under the supported comment-preservation boundary.
+// @evidence contracts/testing.md#distinguishing-cases The original line-comment negative remains and a block-comment negative is added; the uncommented block-else pull-up is the adjacent positive that distinguishes a comment guard from always refusing to join.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationSkipsACommentedGap is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its parsed literal sources and no-finding assertions; the shared syntax-only harness runs the owning rule in process without a consumer install, native product build or product host.
+func TestFormatBraceContinuationSkipsACommentedGap(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/brace-continuation",
+    "if (a) {\n  x();\n}\n// note\nelse {\n  y();\n}\n",
+    `{"tabWidth":2}`,
+  )
+  assertRuleSkipsSourceWithOptions(t, "format/brace-continuation", "if (a) {\n  x();\n} /* note */ else {\n  y();\n}\n", `{"tabWidth":2}`)
+}

package/linthost/format_brace_continuation_waits_for_a_statement_to_own_its_line_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatBraceContinuationWaitsForAStatementToOwnItsLine verifies this rule abstains when a statement shares its line.
+//
+// The prefix before `if` contains `foo();`, not just indentation or labels.
+// braceContinuationIndent therefore declines to infer a column for `else`.
+// The command-level companion owns the final split and placement; this direct
+// rule case observes neither later passes nor another formatter's output.
+//
+//  1. Parse a one-line `if`/`else` that follows another statement on the same line.
+//  2. Run format/brace-continuation.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/brace-continuation must emit no finding while an if shares its physical line with a preceding foo statement and has no independent indentation.
+// @evidence contracts/testing.md#independent-expectations The fixed literal requires this single rule to preserve the shared-line source; its supported deferral policy leaves statement splitting to the cascade rather than inventing an incorrect else column.
+// @evidence contracts/testing.md#distinguishing-cases This direct-rule negative is paired with the command-level shared-line cascade positive that proves eventual splitting and placement; the nested standalone-if positive owns a known nonzero column.
+// @evidence contracts/testing.md#execution-ownership TestFormatBraceContinuationWaitsForAStatementToOwnItsLine is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its parsed literal sources and no-finding assertions; the shared syntax-only harness runs the owning rule in process without a consumer install, native product build or product host.
+func TestFormatBraceContinuationWaitsForAStatementToOwnItsLine(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/brace-continuation",
+    "function f() {\n  foo(); if (a) x(); else y();\n}\n",
+    `{"tabWidth":2}`,
+  )
+}

package/linthost/format_bracket_spacing_idempotent_on_padded_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingIdempotentOnPadded verifies spacing:true is a no-op
+// on an already-padded object literal. This direct case does not run the cascade.
+//
+//  1. Parse `{ x: 1 }`.
+//  2. Run format/bracket-spacing with spacing:true.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must emit no finding for the already-padded single-line object when spacing:true.
+// @evidence contracts/testing.md#independent-expectations The literal { x: 1 } already has the single ASCII space required on each brace interior, so the independent padding policy requires no edit.
+// @evidence contracts/testing.md#distinguishing-cases This canonical-object negative complements TestFormatBracketSpacingPadsObjectLiteral and the inverse spacing:false positive; empty-object cases own the no-interior boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingIdempotentOnPadded is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal source and no-finding assertions; the shared syntax-only harness invokes the owning rule in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingIdempotentOnPadded(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/bracket-spacing",
+    "const a = { x: 1 };\n",
+    `{"spacing":true}`,
+  )
+}

package/linthost/format_bracket_spacing_leaves_a_prettier_shaped_type_literal_alone_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingLeavesAPrettierShapedTypeLiteralAlone verifies the
+// padded type literal produces no finding under the supported spacing policy.
+//
+// This is the negative twin of the unspaced pad. The positive alone would still
+// pass if the rule rewrote every type literal it saw. The literal is an
+// independent padding expectation, not a recorded external formatter result.
+//
+//  1. Parse the independently authored padded type declaration.
+//  2. Run format/bracket-spacing with spacing:true.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must leave the padded alpha/bravo type literal without findings under spacing:true.
+// @evidence contracts/testing.md#independent-expectations The independently authored literal type declaration already satisfies the supported brace-padding policy; no edit is required. This body does not obtain or compare external formatter output.
+// @evidence contracts/testing.md#distinguishing-cases This canonical type-literal negative complements the unspaced type-literal positive, distinguishing an already-padded interior from an unpadded one without claiming this single rule formats every token.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingLeavesAPrettierShapedTypeLiteralAlone is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal source and no-finding assertions; the shared syntax-only harness invokes the owning rule in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingLeavesAPrettierShapedTypeLiteralAlone(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/bracket-spacing",
+    "export type J = { alpha: number; bravo: string };\n",
+    `{"spacing":true}`,
+  )
+}

package/linthost/format_bracket_spacing_leaves_empty_object_test.go

@@ -0,0 +1,74 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingLeavesEmptyObject verifies empty-object boundaries
+// across both spacing modes. Whitespace-only single-line interiors collapse
+// to {}, but multiline interiors and comments retain their content.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must keep exactly empty objects unchanged and collapse single-line ECMAScript horizontal-trivia-only interiors under both spacing options without deleting comments or multiline content; the direct trimming helper must retain NEL, zero-width space and Mongolian vowel separator payload bytes.
+// @evidence contracts/testing.md#independent-expectations Independent literal outputs follow the supported empty-object and brace-padding policies; this body does not obtain external formatter output. ECMAScript WhiteSpace admits Zs, tab, VT, FF and BOM, and excludes NEL, zero-width space and Mongolian vowel separator; direct helper outputs retain those excluded bytes. Comment-bearing outputs retain the comment bytes, while multiline fixtures require no findings because indentation is outside this rule. U+2028 and U+2029 are ECMAScript line terminators, so this single-line rule must abstain rather than normalize their multiline interiors.
+// @evidence contracts/testing.md#distinguishing-cases The original true/false {} negatives remain. Space/tab/mixed interiors and every current Unicode Zs character, VT, FF and BOM are positives under both options; LF/CRLF and bare or space-padded U+2028/U+2029 multiline interiors are negatives and comment-bearing interiors preserve meaning while adding or removing only padding.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingLeavesEmptyObject is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal option/input/output and the original no-finding assertions, including every named Unicode boundary subtest; the direct trimBracketSpacingWhitespace calls retain excluded bytes, and the shared syntax-only harness runs the owning rule and applies edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingLeavesEmptyObject(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/bracket-spacing",
+    "const b = {};\n",
+    `{"spacing":true}`,
+  )
+  assertRuleSkipsSourceWithOptions(t, "format/bracket-spacing", "const b = {};\n", `{"spacing":false}`)
+  for _, options := range []string{`{"spacing":true}`, `{"spacing":false}`} {
+    for _, source := range []string{"const b = {   };\n", "const b = {\t};\n", "const b = { \t };\n"} {
+      assertFixSnapshotWithOptions(t, "format/bracket-spacing", source, options, "const b = {};\n")
+    }
+    assertRuleSkipsSourceWithOptions(t, "format/bracket-spacing", "const b = {\n};\n", options)
+    assertRuleSkipsSourceWithOptions(t, "format/bracket-spacing", "const b = {\r\n};\r\n", options)
+  }
+  assertFixSnapshotWithOptions(t, "format/bracket-spacing", "const b = {/*keep*/};\n", `{"spacing":true}`, "const b = { /*keep*/ };\n")
+  assertFixSnapshotWithOptions(t, "format/bracket-spacing", "const b = { /*keep*/ };\n", `{"spacing":false}`, "const b = {/*keep*/};\n")
+  for _, boundary := range []struct {
+    name     string
+    source   string
+    collapse bool
+  }{
+    {"nbsp", "const b = {\u00a0};\n", true},
+    {"bom", "const b = {\ufeff};\n", true},
+    {"vertical_tab", "const b = {\v};\n", true},
+    {"form_feed", "const b = {\f};\n", true},
+    {"ogham", "const b = {\u1680};\n", true},
+    {"en_quad", "const b = {\u2000};\n", true},
+    {"em_quad", "const b = {\u2001};\n", true},
+    {"en_space", "const b = {\u2002};\n", true},
+    {"em_space", "const b = {\u2003};\n", true},
+    {"three_per_em", "const b = {\u2004};\n", true},
+    {"four_per_em", "const b = {\u2005};\n", true},
+    {"six_per_em", "const b = {\u2006};\n", true},
+    {"figure_space", "const b = {\u2007};\n", true},
+    {"punctuation_space", "const b = {\u2008};\n", true},
+    {"thin_space", "const b = {\u2009};\n", true},
+    {"hair_space", "const b = {\u200a};\n", true},
+    {"narrow_nbsp", "const b = {\u202f};\n", true},
+    {"medium_mathematical_space", "const b = {\u205f};\n", true},
+    {"ideographic_space", "const b = {\u3000};\n", true},
+    {"line_separator", "const b = {\u2028};\n", false},
+    {"paragraph_separator", "const b = {\u2029};\n", false},
+    {"line_separator_padded", "const b = { \u2028 };\n", false},
+    {"paragraph_separator_padded", "const b = { \u2029 };\n", false},
+  } {
+    for _, options := range []string{`{"spacing":true}`, `{"spacing":false}`} {
+      t.Run(boundary.name+"_"+options, func(t *testing.T) {
+        if boundary.collapse {
+          assertFixSnapshotWithOptions(t, "format/bracket-spacing", boundary.source, options, "const b = {};\n")
+        } else {
+          assertRuleSkipsSourceWithOptions(t, "format/bracket-spacing", boundary.source, options)
+        }
+      })
+    }
+  }
+  for _, excluded := range []string{"\u0085", "\u200b", "\u180e"} {
+    if got := trimBracketSpacingWhitespace(" " + excluded + "payload" + excluded + " "); got != excluded+"payload"+excluded {
+      t.Fatalf("must retain non-ECMAScript whitespace %q: got %q", excluded, got)
+    }
+  }
+}

package/linthost/format_bracket_spacing_pads_an_unspaced_type_literal_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsAnUnspacedTypeLiteral verifies the pad is applied
+// while retaining the unspaced member tokens inside it.
+//
+// The rule trims only exterior trivia and pads the remaining interior as one
+// string. It does not rewrite the member colons or separator. This case owns
+// that partial-normalization boundary, not a claim about every formatter rule
+// or an external formatter's output.
+//
+//  1. Parse a type literal with neither brace padding nor interior spacing.
+//  2. Apply format/bracket-spacing with spacing:true.
+//  3. Assert the braces gain their padding and the interior is untouched.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must pad the outer braces of the unspaced type literal while retaining its alpha:number;bravo:string interior exactly.
+// @evidence contracts/testing.md#independent-expectations The full literal output follows this rule's supported partial-normalization boundary: only brace-adjacent spaces change, and both member names and types remain intact. It is deliberately not a claim of complete Prettier normalization.
+// @evidence contracts/testing.md#distinguishing-cases This unpadded type-literal positive complements the independently padded type-literal negative; object and mapped-type positives own distinct AST surfaces for the same brace policy.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsAnUnspacedTypeLiteral is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsAnUnspacedTypeLiteral(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "export type J = {alpha:number;bravo:string};\n",
+    `{"spacing":true}`,
+    "export type J = { alpha:number;bravo:string };\n",
+  )
+}

package/linthost/format_bracket_spacing_pads_destructure_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsDestructure verifies bracketSpacing:true pads a
+// single-line object binding pattern (destructuring).
+//
+//  1. Parse `const {x, y} = obj`.
+//  2. Apply format/bracket-spacing with spacing:true.
+//  3. Assert it becomes `const { x, y } = obj`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must pad a single-line object binding pattern when spacing:true without changing either binding or the source object.
+// @evidence contracts/testing.md#independent-expectations The full literal output adds exactly one brace-interior space on each side while preserving x, y and obj, as required by the configured bracket-spacing policy.
+// @evidence contracts/testing.md#distinguishing-cases This binding-pattern positive distinguishes the parser's ObjectBindingPattern surface from an object expression; canonical-object and empty-object negatives complement the shared padding decision.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsDestructure is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsDestructure(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "const {x, y} = obj;\n",
+    `{"spacing":true}`,
+    "const { x, y } = obj;\n",
+  )
+}

package/linthost/format_bracket_spacing_pads_import_attributes_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsImportAttributes verifies import attributes use
+// the configured inner-brace spacing policy.
+//
+// ImportAttributes starts at `with`, rather than its opening brace. The rule
+// must locate the brace range inside that node instead of assuming node.Pos is
+// the brace itself.
+//
+// 1. Parse an import attribute clause without inner padding.
+// 2. Apply format/bracket-spacing with spacing enabled.
+// 3. Assert exactly one space appears inside the attribute braces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must locate and pad the import-attribute braces even though their AST node starts at with.
+// @evidence contracts/testing.md#independent-expectations The full literal output preserves the default import, module string and type:"json" attribute and inserts only the two spaces demanded by spacing:true.
+// @evidence contracts/testing.md#distinguishing-cases This import-attribute positive catches confusing node start with brace start; named-import padding owns the other import brace surface, while already-padded negatives distinguish no-op behavior.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsImportAttributes is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsImportAttributes(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "import data from \"data\" with {type: \"json\"};\n",
+    `{"spacing":true}`,
+    "import data from \"data\" with { type: \"json\" };\n",
+  )
+}

package/linthost/format_bracket_spacing_pads_mapped_type_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsMappedType verifies mapped types participate in
+// the same inner-brace spacing policy as ordinary type literals.
+//
+// A mapped type has a distinct syntax kind, so visiting TypeLiteral alone
+// could never reach its braces.
+//
+// 1. Parse an unpadded mapped type.
+// 2. Apply format/bracket-spacing with spacing enabled.
+// 3. Assert exactly one space appears inside each brace.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must pad the distinct mapped-type brace surface without changing the key iteration or indexed value type.
+// @evidence contracts/testing.md#independent-expectations The complete literal output preserves K in keyof T and T[K] and adds only the brace padding required by spacing:true.
+// @evidence contracts/testing.md#distinguishing-cases This mapped-type positive is distinct from ordinary type literals and object bindings; the canonical type-literal negative owns an already-spaced case under the same policy.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsMappedType is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsMappedType(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "type M<T> = {[K in keyof T]: T[K]};\n",
+    `{"spacing":true}`,
+    "type M<T> = { [K in keyof T]: T[K] };\n",
+  )
+}

package/linthost/format_bracket_spacing_pads_named_imports_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsNamedImports verifies bracketSpacing:true pads
+// a single-line named import's braces.
+//
+//  1. Parse `import {foo, bar} from "m"`.
+//  2. Apply format/bracket-spacing with spacing:true.
+//  3. Assert it becomes `import { foo, bar } from "m"`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must pad the braces around a single-line named import without changing its imported names or module specifier.
+// @evidence contracts/testing.md#independent-expectations The complete literal output retains foo, bar and module m and adds exactly one space at each brace interior according to spacing:true.
+// @evidence contracts/testing.md#distinguishing-cases This NamedImports positive complements the ImportAttributes positive with its different brace location, and already-padded object/type negatives own abstention under the same spacing option.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsNamedImports is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsNamedImports(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "import {foo, bar} from \"m\";\n",
+    `{"spacing":true}`,
+    "import { foo, bar } from \"m\";\n",
+  )
+}

package/linthost/format_bracket_spacing_pads_object_literal_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingPadsObjectLiteral verifies bracketSpacing:true (the
+// default, matching Prettier) adds one inner space to a single-line object
+// literal.
+//
+//  1. Parse `{x: 1}`.
+//  2. Apply format/bracket-spacing with spacing:true.
+//  3. Assert it becomes `{ x: 1 }`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must add the configured single inner space at each side of the nonempty object literal.
+// @evidence contracts/testing.md#independent-expectations The full literal outputs add exactly the two ASCII spaces demanded by spacing:true to `{x: 1}`, and, for the second input whose brace-adjacent trivia is only NBSP characters, replace each NBSP with one ASCII space while leaving the NBSP inside the string value byte-for-byte.
+// @evidence contracts/testing.md#distinguishing-cases The unpadded `{x: 1}` positive pairs with TestFormatBracketSpacingIdempotentOnPadded; the NBSP-trivia input distinguishes brace-adjacent whitespace from the identical significant NBSP inside the string literal. The spacing:false inverse and the empty object are owned by other tests.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingPadsObjectLiteral is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingPadsObjectLiteral(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "const a = {x: 1};\n",
+    `{"spacing":true}`,
+    "const a = { x: 1 };\n",
+  )
+  assertFixSnapshotWithOptions(t, "format/bracket-spacing", "const a = {\u00a0x: \"\u00a0\"\u00a0};\n", `{"spacing":true}`, "const a = { x: \"\u00a0\" };\n")
+}

package/linthost/format_bracket_spacing_strips_object_literal_under_false_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatBracketSpacingStripsObjectLiteralUnderFalse verifies
+// bracketSpacing:false removes the inner space of a single-line object
+// literal.
+//
+//  1. Parse `{ x: 1 }`.
+//  2. Apply format/bracket-spacing with spacing:false.
+//  3. Assert it becomes `{x: 1}`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/bracket-spacing must remove both brace-interior spaces from a nonempty object under spacing:false.
+// @evidence contracts/testing.md#independent-expectations The full literal outputs remove all brace-adjacent whitespace under spacing:false: `{ x: 1 }` becomes `{x: 1}`, and the mixed ASCII-and-NBSP trivia input becomes `{x: " "}` with the NBSP inside the string preserved byte-for-byte.
+// @evidence contracts/testing.md#distinguishing-cases The inverse of the padding positive; the second input distinguishes brace-adjacent mixed ASCII/NBSP trivia (removed) from the identical NBSP inside a string literal (kept). The empty-object test owns the no-interior boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatBracketSpacingStripsObjectLiteralUnderFalse is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatBracketSpacingStripsObjectLiteralUnderFalse(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/bracket-spacing",
+    "const a = { x: 1 };\n",
+    `{"spacing":false}`,
+    "const a = {x: 1};\n",
+  )
+  assertFixSnapshotWithOptions(t, "format/bracket-spacing", "const a = { \u00a0x: \"\u00a0\"\u00a0 };\n", `{"spacing":false}`, "const a = {x: \"\u00a0\"};\n")
+}

package/linthost/format_clause_join_charges_the_else_width_budget_at_its_limit_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatClauseJoinChargesTheElseWidthBudgetAtItsLimit verifies the printWidth budget
+// for an `else` clause is charged at its exact limit.
+//
+// `else stopEverything();` is 22 ASCII display columns. The supported width
+// policy joins at 22 and refuses at 21, so this case walks the boundary from
+// both sides rather than picking a width comfortably past it. A budget measured
+// from the enclosing `if` instead of the `else` keyword would charge the wrong
+// column here.
+//
+//  1. Run format/clause-join on the same source at printWidth 22 and 21.
+//  2. Assert the join lands at 22.
+//  3. Assert nothing is reported at 21.
+//
+// @evidence contracts/testing.md#behavioral-verification The owning clause-join rule must join else stopEverything(); at width 22 and report nothing at 21; complete output and no-finding assertions detect charging the wrong anchor column.
+// @evidence contracts/testing.md#independent-expectations The ASCII line else stopEverything(); has 22 columns, so the independently chosen adjacent widths distinguish fitting exactly from exceeding the supported budget. Expected output retains the if branch and call spelling; this body does not obtain external formatter output.
+// @evidence contracts/testing.md#distinguishing-cases The identical else input is a positive at its exact limit and a negative one column below. Ordinary if joining is covered by JoinsSingleIfBody.
+// @evidence contracts/testing.md#execution-ownership TestFormatClauseJoinChargesTheElseWidthBudgetAtItsLimit owns both literal width fixtures in the public Go unit population. The syntax-only harness executes the owning rule and applies edits in process without installing a consumer, building a native artifact or starting a product host.
+func TestFormatClauseJoinChargesTheElseWidthBudgetAtItsLimit(t *testing.T) {
+  const source = "if (ready) run();\nelse\n  stopEverything();\n"
+  assertFixSnapshotWithOptions(
+    t,
+    "format/clause-join",
+    source,
+    `{"printWidth":22,"tabWidth":2}`,
+    "if (ready) run();\nelse stopEverything();\n",
+  )
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/clause-join",
+    source,
+    `{"printWidth":21,"tabWidth":2}`,
+  )
+}

package/linthost/format_clause_join_charges_the_shift_to_the_header_lines_indent_test.go

@@ -0,0 +1,45 @@
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestFormatClauseJoinChargesTheShiftToTheHeaderLinesIndent verifies the delta is the header line's indent, not the anchor token's column.
+//
+// In the literal `} else` header the anchor token starts two columns after the
+// line's indentation. The multiline labeled-loop fixture requires the final
+// continuation columns to follow the header line's indentation rather than
+// charge that prefix. The command assertion observes the final output, not
+// individual edits or an external formatter result.
+//
+//  1. Seed a project with a `} else` chain whose body is a labeled loop.
+//  2. Run `ttsc format`.
+//  3. Assert the complete nested-body output has the independently stated columns.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format entry must flatten the else-if header and outdent the labeled loop by the header line indentation; exact status, streams and file bytes distinguish accidentally adding the } prefix width to continuation columns.
+// @evidence contracts/testing.md#independent-expectations The literal canonical layout keeps } else at column zero and the labeled loop one level below its nested if. This formatter contract preserves all branch conditions and visit calls independently of computed edit offsets.
+// @evidence contracts/testing.md#distinguishing-cases The } else prefix supplies a nonzero anchor column on a zero-indent line; the labeled loop retains multiline content. ReindentsAHoistedBodyInsideAFunction covers nonzero enclosing indentation.
+// @evidence contracts/testing.md#execution-ownership TestFormatClauseJoinChargesTheShiftToTheHeaderLinesIndent is a public Go unit owning its fixture configuration, direct run(format) call, captured streams and filesystem assertion. Project helpers and formatter cascade execute in the same test process; there is no consumer installation, native build or child product host.
+func TestFormatClauseJoinChargesTheShiftToTheHeaderLinesIndent(t *testing.T) {
+  root := seedLintProject(t, "if (a) {\n  x();\n} else\n  if (b)\n    outer: for (const x of xs) {\n      visit(x);\n    }\n")
+  seedLintConfig(t, root, map[string]any{"format": map[string]any{}})
+  code, stdout, stderr := captureCommandOutput(t, func() int {
+    return run([]string{
+      "format",
+      "--cwd", root,
+      "--plugins-json", lintManifest(t),
+    })
+  })
+  if code != 0 || stdout != "" || stderr != "" {
+    t.Fatalf("format command mismatch: code=%d stdout=%q stderr=%q", code, stdout, stderr)
+  }
+  got, err := os.ReadFile(filepath.Join(root, "src", "main.ts"))
+  if err != nil {
+    t.Fatalf("ReadFile: %v", err)
+  }
+  if want := "if (a) {\n  x();\n} else if (b)\n  outer: for (const x of xs) {\n    visit(x);\n  }\n"; string(got) != want {
+    t.Fatalf("formatted source mismatch:\nwant %q\ngot  %q", want, string(got))
+  }
+}