@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/config_format.go

@@ -3,13 +3,14 @@ package linthost
 import (
   "encoding/json"
   "fmt"
+  "strings"
 )
 
 // expandFormatBlock translates a Prettier-style `format` block into the
 // per-rule severity + options shape the existing rule parsers consume.
 // The result is a `map[string]any` that mirrors what a user would
-// have written under `rules` directly — entries like
-// `"format/semi": ["off", {"prefer": "always"}]` — so the caller
+// have written under `rules` directly, entries like
+// `"format/semi": ["off", {"prefer": "always"}]`, so the caller
 // can route it through either `ParseRulesWithOptions` or
 // `parseExternalRuleMapInto` without duplicating option-decoding logic.
 //
@@ -20,16 +21,27 @@ import (
 //
 // The block's enablement matrix:
 //
-//   - `format/semi` — always on. `semi: false` flips to `prefer: "never"`.
-//   - `format/quotes` — always on. `singleQuote: true` flips to `prefer: "single"`.
-//   - `format/trailing-comma` — always on with the requested mode.
-//   - `format/print-width` — always on, driven by printWidth/tabWidth/useTabs/endOfLine.
-//   - `format/sort-imports` — opt-in by setting `importOrder`.
-//   - `format/jsdoc` — opt-in by setting `jsdoc` truthy.
+//   - `format/semi`, always on. `semi: false` flips to `prefer: "never"`.
+//   - `format/quotes`, always on. `singleQuote: true` flips to `prefer: "single"`.
+//   - `format/arrow-parens`, always on. `arrowParens: "avoid"` strips a single bare-identifier arrow parameter's parens; default "always" adds them.
+//   - `format/bracket-spacing`, always on. `bracketSpacing: false` removes the inner space of single-line object/destructure/import/export/type braces; default true keeps it.
+//   - `format/quote-props`, always on. `quoteProps: "as-needed"` (default) unquotes identifier object keys; "consistent" keeps all keys quoted when any needs it; "preserve" leaves quoting alone.
+//   - `format/trailing-comma`, always on with the requested mode.
+//   - `format/print-width`, always on, driven by printWidth/tabWidth/useTabs/endOfLine.
+//   - `format/clause-join`, always on, joins a single-statement clause body that fits printWidth.
+//   - `format/declaration-header`, always on, reflows a class/interface header's type params and heritage clauses.
+//   - `format/ternary-nullish-parens`, always on, parenthesizes a `??` operand of a conditional expression.
+//   - `format/orphan-semi`, always on; under semi:false, merges a leading-semicolon ASI guard onto its statement.
+//   - `format/parameter-properties`, always on, breaks a constructor's parameter list when it has parameter properties.
+//   - `format/statement-split`, always on, driven by tabWidth/useTabs/endOfLine.
+//   - `format/indent`, always on, driven by tabWidth/useTabs/endOfLine.
+//   - `format/whitespace`, always on, driven by endOfLine.
+//   - `format/sort-imports`, opt-in by setting `sortImports`.
+//   - `format/jsdoc`, always-on; `jsDoc: false` opts out, an object customizes.
 //
 // The returned map is the raw form rules parsers expect. Callers MUST
 // merge any user-supplied `rules` map on top of this one (rules-wins
-// semantics) before invoking the existing parsers — `mergeRuleMaps`
+// semantics) before invoking the existing parsers, `mergeRuleMaps`
 // below performs the merge with the right precedence.
 func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   if raw == nil {
@@ -60,6 +72,10 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/semi"] = ruleEntry(map[string]any{"prefer": semiPrefer})
 
+  // formatOrphanSemi, always on; mirrors the effective semi setting so
+  // it only merges the leading-semicolon ASI guard under semi:false.
+  out["format/orphan-semi"] = ruleEntry(map[string]any{"semi": semiPrefer == "always"})
+
   // formatQuotes
   quotesPrefer := "double"
   if v, ok := raw["singleQuote"]; ok {
@@ -73,6 +89,56 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   }
   out["format/quotes"] = ruleEntry(map[string]any{"prefer": quotesPrefer})
 
+  // formatArrowParens, always on. Mirrors Prettier's arrowParens; the
+  // default "always" parenthesizes a single bare-identifier arrow parameter,
+  // "avoid" strips the parens.
+  arrowPrefer := "always"
+  if v, ok := raw["arrowParens"]; ok {
+    s, err := asString("format.arrowParens", v)
+    if err != nil {
+      return nil, err
+    }
+    switch s {
+    case "always", "avoid":
+      arrowPrefer = s
+    default:
+      return nil, fmt.Errorf("@ttsc/lint: format.arrowParens must be \"always\" or \"avoid\"; got %q", s)
+    }
+  }
+  out["format/arrow-parens"] = ruleEntry(map[string]any{"prefer": arrowPrefer})
+
+  // formatBracketSpacing, always on. Mirrors Prettier's bracketSpacing;
+  // the default true pads single-line object/destructure/import/export/type
+  // braces with one inner space, false removes it.
+  bracketSpacing := true
+  if v, ok := raw["bracketSpacing"]; ok {
+    b, err := asBool("format.bracketSpacing", v)
+    if err != nil {
+      return nil, err
+    }
+    bracketSpacing = b
+  }
+  out["format/bracket-spacing"] = ruleEntry(map[string]any{"spacing": bracketSpacing})
+
+  // formatQuoteProps, always on. Mirrors Prettier's quoteProps; the default
+  // "as-needed" unquotes object keys that are valid identifiers, "consistent"
+  // keeps every key quoted when any one needs it, "preserve" leaves quoting
+  // untouched.
+  quoteProps := "as-needed"
+  if v, ok := raw["quoteProps"]; ok {
+    s, err := asString("format.quoteProps", v)
+    if err != nil {
+      return nil, err
+    }
+    switch s {
+    case "as-needed", "consistent", "preserve":
+      quoteProps = s
+    default:
+      return nil, fmt.Errorf("@ttsc/lint: format.quoteProps must be \"as-needed\", \"consistent\", or \"preserve\"; got %q", s)
+    }
+  }
+  out["format/quote-props"] = ruleEntry(map[string]any{"mode": quoteProps})
+
   // formatTrailingComma
   tcMode := "all"
   if v, ok := raw["trailingComma"]; ok {
@@ -95,9 +161,14 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   // the printer's broken-list reflow emits the same trailing-comma
   // shape `format/trailing-comma` does. Without the mirror the two
   // rules disagree on `es5` / `none` projects and oscillate on every
-  // cascade pass — the trailing-comma rule says "no comma" while the
+  // cascade pass, the trailing-comma rule says "no comma" while the
   // printer adds one back. See `printArgList` in print_nodes_call.go.
-  pwOpts := map[string]any{"trailingComma": tcMode}
+  layoutOpts, err := collectLayoutOpts(raw)
+  if err != nil {
+    return nil, err
+  }
+  pwOpts := cloneStringAnyMap(layoutOpts)
+  pwOpts["trailingComma"] = tcMode
   if v, ok := raw["printWidth"]; ok {
     n, err := asInt("format.printWidth", v)
     if err != nil {
@@ -108,116 +179,153 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
     }
     pwOpts["printWidth"] = n
   }
-  if v, ok := raw["tabWidth"]; ok {
-    n, err := asInt("format.tabWidth", v)
-    if err != nil {
-      return nil, err
-    }
-    if n < 1 {
-      return nil, fmt.Errorf("@ttsc/lint: format.tabWidth must be a positive integer; got %d", n)
-    }
-    pwOpts["tabWidth"] = n
-  }
-  if v, ok := raw["useTabs"]; ok {
-    b, err := asBool("format.useTabs", v)
-    if err != nil {
-      return nil, err
-    }
-    pwOpts["useTabs"] = b
-  }
-  if v, ok := raw["endOfLine"]; ok {
-    s, err := asString("format.endOfLine", v)
-    if err != nil {
-      return nil, err
-    }
-    if s != "lf" && s != "crlf" {
-      return nil, fmt.Errorf("@ttsc/lint: format.endOfLine must be \"lf\" or \"crlf\"; got %q", s)
-    }
-    pwOpts["endOfLine"] = s
-  }
   out["format/print-width"] = ruleEntry(pwOpts)
 
-  // formatSortImports — opt-in by `importOrder`.
-  if v, ok := raw["importOrder"]; ok {
-    siOpts := map[string]any{}
-    order, err := asStringSlice("format.importOrder", v)
+  // formatClauseJoin, always on. Reuses the printWidth/tabWidth/useTabs
+  // budget so it only joins a single-statement clause body back onto its
+  // header when the joined line fits. A distinct map instance so it does
+  // not alias the print-width blob.
+  out["format/clause-join"] = ruleEntry(cloneStringAnyMap(pwOpts))
+
+  // formatDeclarationHeader, always on. Reflows a class/interface header
+  // (type parameters + heritage clauses) to Prettier's break shapes;
+  // needs the same printWidth/tabWidth/useTabs budget.
+  out["format/declaration-header"] = ruleEntry(cloneStringAnyMap(pwOpts))
+
+  // formatTernaryNullishParens, always on, no options: wraps a `??`
+  // operand of a conditional expression in parentheses (Prettier 3).
+  out["format/ternary-nullish-parens"] = ruleEntry(map[string]any{})
+
+  // formatStatementSplit + formatIndent, always on, Prettier-style.
+  // Both reuse the indentation/EOL settings to synthesize line breaks
+  // and indent strings. Only the keys the user actually set are mirrored
+  // in (same conditional shape as print-width's pwOpts), so defaults are
+  // applied rule-side. The two rules share the same option surface
+  // collected once into layoutOpts above.
+  //
+  // Distinct map instances so the two rule entries don't alias one blob.
+  out["format/statement-split"] = ruleEntry(cloneStringAnyMap(layoutOpts))
+  out["format/indent"] = ruleEntry(cloneStringAnyMap(layoutOpts))
+
+  // formatParameterProperties, always on. Force-breaks a constructor's
+  // parameter list when it declares parameter properties; needs only the
+  // indentation settings.
+  out["format/parameter-properties"] = ruleEntry(cloneStringAnyMap(layoutOpts))
+
+  // formatWhitespace, always on. Needs only endOfLine for the final
+  // newline; indentation is irrelevant to text hygiene.
+  wsOpts := map[string]any{}
+  if v, ok := layoutOpts["endOfLine"]; ok {
+    wsOpts["endOfLine"] = v
+  }
+  out["format/whitespace"] = ruleEntry(wsOpts)
+
+  // formatSortImports, opt-in by `sortImports` (a boolean or options object).
+  if v, ok := raw["sortImports"]; ok && v != nil {
+    siOpts, enabled, err := expandSortImportsBlock(v)
     if err != nil {
       return nil, err
     }
-    if len(order) == 0 {
-      return nil, fmt.Errorf("@ttsc/lint: format.importOrder must contain at least one entry; omit the field to keep formatSortImports off")
-    }
-    siOpts["importOrder"] = order
-    if x, ok := raw["importOrderSeparation"]; ok {
-      b, err := asBool("format.importOrderSeparation", x)
-      if err != nil {
-        return nil, err
-      }
-      siOpts["importOrderSeparation"] = b
-    }
-    if x, ok := raw["importOrderSortSpecifiers"]; ok {
-      b, err := asBool("format.importOrderSortSpecifiers", x)
-      if err != nil {
-        return nil, err
-      }
-      siOpts["importOrderSortSpecifiers"] = b
-    }
-    if x, ok := raw["importOrderCaseInsensitive"]; ok {
-      b, err := asBool("format.importOrderCaseInsensitive", x)
-      if err != nil {
-        return nil, err
-      }
-      siOpts["importOrderCaseInsensitive"] = b
+    if enabled {
+      out["format/sort-imports"] = ruleEntry(siOpts)
     }
-    out["format/sort-imports"] = ruleEntry(siOpts)
   }
 
-  // formatJsdoc — opt-in by `jsdoc` truthy (boolean or object).
-  if v, ok := raw["jsdoc"]; ok && v != nil {
-    jdOpts := map[string]any{}
-    enabled := false
+  // formatJsdoc, always-on. `jsDoc: false` opts out; a
+  // `{ tagSynonyms, sortTags }` object customizes it. The config key is
+  // camelCased (jsDoc) to match the other multi-word keys; the emitted rule id
+  // stays `format/jsdoc`.
+  //
+  // Today the rule only rewrites tag synonyms (@return → @returns, ...); tag
+  // sorting, column alignment, and wrapping are on the roadmap. It is on by
+  // default so JSDoc tag names normalize without opt-in, matching the rest of
+  // the always-on format set.
+  jdOpts := map[string]any{}
+  jdEnabled := true
+  if v, ok := raw["jsDoc"]; ok && v != nil {
     switch j := v.(type) {
     case bool:
-      enabled = j
+      jdEnabled = j
     case map[string]any:
-      enabled = true
       for key, val := range j {
         switch key {
         case "tagSynonyms":
           ts, ok := val.(map[string]any)
           if !ok {
-            return nil, fmt.Errorf("@ttsc/lint: format.jsdoc.tagSynonyms must be an object, got %T", val)
+            return nil, fmt.Errorf("@ttsc/lint: format.jsDoc.tagSynonyms must be an object, got %T", val)
           }
           // Element values must be strings; surface
           // typos early instead of after a downstream
           // JSON-decode failure.
           for k, v := range ts {
             if _, ok := v.(string); !ok {
-              return nil, fmt.Errorf("@ttsc/lint: format.jsdoc.tagSynonyms[%q] must be a string, got %T", k, v)
+              return nil, fmt.Errorf("@ttsc/lint: format.jsDoc.tagSynonyms[%q] must be a string, got %T", k, v)
             }
           }
           jdOpts["tagSynonyms"] = ts
         case "sortTags":
-          b, err := asBool("format.jsdoc.sortTags", val)
+          b, err := asBool("format.jsDoc.sortTags", val)
           if err != nil {
             return nil, err
           }
           jdOpts["sortTags"] = b
         default:
-          return nil, fmt.Errorf("@ttsc/lint: format.jsdoc unknown key %q (allowed: tagSynonyms, sortTags)", key)
+          return nil, fmt.Errorf("@ttsc/lint: format.jsDoc unknown key %q (allowed: tagSynonyms, sortTags)", key)
         }
       }
     default:
-      return nil, fmt.Errorf("@ttsc/lint: format.jsdoc must be a boolean or object, got %T", v)
-    }
-    if enabled {
-      out["format/jsdoc"] = ruleEntry(jdOpts)
+      return nil, fmt.Errorf("@ttsc/lint: format.jsDoc must be a boolean or object, got %T", v)
     }
   }
+  if jdEnabled {
+    out["format/jsdoc"] = ruleEntry(jdOpts)
+  }
 
   return out, nil
 }
 
+// expandSortImportsBlock translates the `format.sortImports` value (a boolean
+// or an options object) into the rule's option map. The bool reports whether
+// the rule is enabled: `true` and any object enable it, `false` keeps it off.
+func expandSortImportsBlock(v any) (map[string]any, bool, error) {
+  switch sv := v.(type) {
+  case bool:
+    return map[string]any{}, sv, nil
+  case map[string]any:
+    opts := map[string]any{}
+    for key, val := range sv {
+      switch key {
+      case "order":
+        order, err := asStringSlice("format.sortImports.order", val)
+        if err != nil {
+          return nil, false, err
+        }
+        if len(order) == 0 {
+          return nil, false, fmt.Errorf("@ttsc/lint: format.sortImports.order must contain at least one entry; omit it to use the default order")
+        }
+        opts["order"] = order
+      case "caseSensitive":
+        b, err := asBool("format.sortImports.caseSensitive", val)
+        if err != nil {
+          return nil, false, err
+        }
+        opts["caseSensitive"] = b
+      case "combineTypeAndValue":
+        b, err := asBool("format.sortImports.combineTypeAndValue", val)
+        if err != nil {
+          return nil, false, err
+        }
+        opts["combineTypeAndValue"] = b
+      default:
+        return nil, false, fmt.Errorf("@ttsc/lint: format.sortImports unknown key %q (allowed: order, caseSensitive, combineTypeAndValue)", key)
+      }
+    }
+    return opts, true, nil
+  default:
+    return nil, false, fmt.Errorf("@ttsc/lint: format.sortImports must be a boolean or object, got %T", v)
+  }
+}
+
 // formatBlockSeverity extracts the optional `severity` field from a format
 // block. Defaults to SeverityOff so that format rules never produce check/build
 // diagnostics unless the user explicitly opts in. SeverityOff still allows
@@ -234,12 +342,20 @@ func formatBlockSeverity(raw map[string]any) (Severity, error) {
   return severity, nil
 }
 
+// isFormatRuleName reports whether `name` is a formatter rule id. Such
+// rules are configured exclusively through the `format` block; a `format/*`
+// key in the user's `rules` map is dropped before the merge, so the config
+// layer never carries a formatter setting in two places.
+func isFormatRuleName(name string) bool {
+  return strings.HasPrefix(name, "format/")
+}
+
 // mergeRuleMaps overlays `overrides` on `base` and returns the merged
 // map. Identical keys in `overrides` replace the entire entry from
-// `base`; option objects are NOT deep-merged, which matches the
-// conflict-resolution policy spec: a `rules` entry that names a
-// `format/*` rule fully replaces the corresponding entry expanded
-// from the `format` block.
+// `base`; option objects are NOT deep-merged. `overrides` (the user's
+// `rules` map) never contains a `format/*` key, those are dropped before
+// the merge, so the merge only ever layers lint-rule severities on top of
+// the format block's expanded entries.
 func mergeRuleMaps(base, overrides map[string]any) map[string]any {
   out := make(map[string]any, len(base)+len(overrides))
   for k, v := range base {
@@ -251,6 +367,56 @@ func mergeRuleMaps(base, overrides map[string]any) map[string]any {
   return out
 }
 
+// cloneStringAnyMap returns a shallow copy of `m`. expandFormatBlock uses
+// it so `format/statement-split` and `format/indent` each receive their
+// own options blob rather than aliasing one shared map, a later mutation
+// or marshal of one entry then cannot leak into the other.
+func cloneStringAnyMap(m map[string]any) map[string]any {
+  out := make(map[string]any, len(m))
+  for k, v := range m {
+    out[k] = v
+  }
+  return out
+}
+
+// collectLayoutOpts parses the shared tabWidth/useTabs/endOfLine layout
+// fields from a format block once. Only keys the user actually set are
+// emitted, so rule-side defaults still apply for absent fields. Both the
+// print-width blob (which adds trailingComma + printWidth) and the
+// statement-split/indent/parameter-properties entries derive from this
+// single source so their parse-and-validate logic stays in one place.
+func collectLayoutOpts(raw map[string]any) (map[string]any, error) {
+  layoutOpts := map[string]any{}
+  if v, ok := raw["tabWidth"]; ok {
+    n, err := asInt("format.tabWidth", v)
+    if err != nil {
+      return nil, err
+    }
+    if n < 1 {
+      return nil, fmt.Errorf("@ttsc/lint: format.tabWidth must be a positive integer; got %d", n)
+    }
+    layoutOpts["tabWidth"] = n
+  }
+  if v, ok := raw["useTabs"]; ok {
+    b, err := asBool("format.useTabs", v)
+    if err != nil {
+      return nil, err
+    }
+    layoutOpts["useTabs"] = b
+  }
+  if v, ok := raw["endOfLine"]; ok {
+    s, err := asString("format.endOfLine", v)
+    if err != nil {
+      return nil, err
+    }
+    if s != "lf" && s != "crlf" {
+      return nil, fmt.Errorf("@ttsc/lint: format.endOfLine must be \"lf\" or \"crlf\"; got %q", s)
+    }
+    layoutOpts["endOfLine"] = s
+  }
+  return layoutOpts, nil
+}
+
 // asBool coerces a raw config value to a bool, returning a typed error on
 // failure. Used by expandFormatBlock to validate boolean format fields.
 func asBool(field string, v any) (bool, error) {
@@ -295,7 +461,7 @@ func asInt(field string, v any) (int, error) {
 }
 
 // asStringSlice coerces a raw config value to a []string, returning a typed
-// error on failure. Used by expandFormatBlock to validate importOrder.
+// error on failure. Used by expandFormatBlock to validate sortImports.order.
 func asStringSlice(field string, v any) ([]string, error) {
   arr, ok := v.([]any)
   if !ok {
@@ -317,19 +483,19 @@ func asStringSlice(field string, v any) ([]string, error) {
 // key set mirrors `ITtscLintFormat` exactly.
 func rejectUnknownFormatKeys(raw map[string]any) error {
   allowed := map[string]struct{}{
-    "severity":                   {},
-    "semi":                       {},
-    "singleQuote":                {},
-    "trailingComma":              {},
-    "printWidth":                 {},
-    "tabWidth":                   {},
-    "useTabs":                    {},
-    "endOfLine":                  {},
-    "importOrder":                {},
-    "importOrderSeparation":      {},
-    "importOrderSortSpecifiers":  {},
-    "importOrderCaseInsensitive": {},
-    "jsdoc":                      {},
+    "severity":       {},
+    "semi":           {},
+    "singleQuote":    {},
+    "arrowParens":    {},
+    "bracketSpacing": {},
+    "quoteProps":     {},
+    "trailingComma":  {},
+    "printWidth":     {},
+    "tabWidth":       {},
+    "useTabs":        {},
+    "endOfLine":      {},
+    "sortImports":    {},
+    "jsDoc":          {},
   }
   for key := range raw {
     if _, ok := allowed[key]; !ok {

package/linthost/directives.go

@@ -194,7 +194,11 @@ scan:
     }
     switch directive.kind {
     case lintDirectiveDisableLine:
-      directives.lines[startLine] = append(directives.lines[startLine], directive.rules)
+      // Key on endLine, not startLine, so a multi-line block-comment
+      // `disable-line` reasons about the comment's end the same way
+      // disable-next-line does (endLine+1). A single-line comment has
+      // startLine == endLine, so same-line suppression is unchanged.
+      directives.lines[endLine] = append(directives.lines[endLine], directive.rules)
     case lintDirectiveDisableNextLine:
       directives.lines[endLine+1] = append(directives.lines[endLine+1], directive.rules)
     case lintDirectiveDisable:

package/linthost/display_width.go

@@ -0,0 +1,72 @@
+package linthost
+
+import "unicode"
+
+// displayWidth returns the number of terminal columns a string occupies,
+// matching Prettier's getStringWidth: an ASCII string's width equals its byte
+// length, a zero-width combining mark counts as zero, and a wide East Asian
+// (or emoji) code point counts as two. Width decisions across the formatter,
+// the layout engine's fit checks and the print-width rule's source measurement,
+// must use display columns rather than byte length, or a multi-byte token (a
+// subscript digit, a Hangul or CJK identifier) is over-counted and the line is
+// wrongly broken.
+//
+// A tab counts as one column here; callers that need tab-stop expansion handle
+// it separately (the layout engine emits indentation outside of Text nodes, so
+// an embedded tab is rare and was already charged as one byte before this).
+func displayWidth(s string) int {
+  w := 0
+  for _, r := range s {
+    w += runeWidth(r)
+  }
+  return w
+}
+
+// displayWidthAfterLastNewline returns the display width of the substring that
+// follows the final newline in s (the whole string when it has none). The
+// layout engine uses it to reset the running column after emitting a verbatim
+// slice that spans lines.
+func displayWidthAfterLastNewline(s string) int {
+  for i := len(s) - 1; i >= 0; i-- {
+    if s[i] == '\n' {
+      return displayWidth(s[i+1:])
+    }
+  }
+  return displayWidth(s)
+}
+
+// runeWidth returns the column width of a single rune: zero for a combining
+// mark or zero-width space, two for a wide East Asian or emoji code point, one
+// otherwise (tabs included, see displayWidth).
+func runeWidth(r rune) int {
+  if r == 0x200B || unicode.Is(unicode.Mn, r) || unicode.Is(unicode.Me, r) {
+    return 0
+  }
+  if isWideRune(r) {
+    return 2
+  }
+  return 1
+}
+
+// isWideRune reports whether a rune renders in two terminal columns, covering
+// the East Asian Wide / Fullwidth ranges and the common emoji blocks the way
+// Prettier's width table does.
+func isWideRune(r rune) bool {
+  switch {
+  case r >= 0x1100 && r <= 0x115F, // Hangul Jamo
+    r >= 0x2E80 && r <= 0x303E,   // CJK Radicals .. CJK Symbols (part)
+    r >= 0x3041 && r <= 0x33FF,   // Hiragana .. CJK Compatibility
+    r >= 0x3400 && r <= 0x4DBF,   // CJK Extension A
+    r >= 0x4E00 && r <= 0x9FFF,   // CJK Unified Ideographs
+    r >= 0xA000 && r <= 0xA4CF,   // Yi
+    r >= 0xAC00 && r <= 0xD7A3,   // Hangul Syllables
+    r >= 0xF900 && r <= 0xFAFF,   // CJK Compatibility Ideographs
+    r >= 0xFE30 && r <= 0xFE4F,   // CJK Compatibility Forms
+    r >= 0xFF00 && r <= 0xFF60,   // Fullwidth Forms
+    r >= 0xFFE0 && r <= 0xFFE6,   // Fullwidth signs
+    r >= 0x1F300 && r <= 0x1FAFF, // emoji & pictographs
+    r >= 0x20000 && r <= 0x3FFFD: // CJK Extension B and beyond
+    return true
+  }
+  return false
+}

package/linthost/fix.go

@@ -43,7 +43,14 @@ func runFix(opts *subcommandOpts) int {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  engine := NewEngineWithResolver(rules)
+  // `ttsc fix` is the run-everything entry point: lint fixes AND formatter
+  // edits. Formatting is configured solely through the `format` block (a
+  // format/* key in `rules` is dropped), so wrap the resolver the same way
+  // `ttsc format` and the LSP paths do — formatCommandResolver force-
+  // activates the format rules the format block configured. A project with
+  // no format block populates no format options, so nothing extra is enabled
+  // and fix stays a pure lint pass.
+  engine := NewEngineWithResolver(formatCommandResolver{inner: rules})
   engine.SetSerial(opts.singleThreaded)
   needsRuleChecker := engine.NeedsTypeChecker()
 
@@ -258,12 +265,30 @@ func selectTextEdits(sourceLen int, edits []TextEdit) []TextEdit {
 
   selected := make([]TextEdit, 0, len(sorted))
   lastEnd := -1
+  // lastInsertAt marks the offset of the previously-selected edit when that
+  // edit was a zero-width insert (Pos==End), else -1. A new zero-width
+  // insert at that same offset must be dropped: two coincident inserts both
+  // pass the `edit.Pos < lastEnd` gate, then apply in reverse sort order and
+  // concatenate at one point — silently corrupting the source (e.g. a `;`
+  // insert and a `\n` insert at EOF yielding `\n;`). The host contract keeps
+  // one winner and drops the rest (see rule.TextEdit). A zero-width insert
+  // sitting at the end of a prior NON-empty edit is left alone: it applies
+  // cleanly after the replacement and is a legitimate adjacency.
+  lastInsertAt := -1
   for _, edit := range sorted {
     if edit.Pos < lastEnd {
       continue
     }
+    if edit.Pos == edit.End && edit.Pos == lastInsertAt {
+      continue
+    }
     selected = append(selected, edit)
     lastEnd = edit.End
+    if edit.Pos == edit.End {
+      lastInsertAt = edit.Pos
+    } else {
+      lastInsertAt = -1
+    }
   }
   return selected
 }