@ttsc/lint 0.14.0 → 0.14.1

package/README.md

@@ -66,8 +66,8 @@ export default {
   rules: {
     "no-var": "error",
     "prefer-const": "error",
-    "typescript/no-explicit-any": "warning",
-    "no-console": "off",
+    "typescript/no-explicit-any": "error",
+    "typescript/no-floating-promises": "error",
   },
 } satisfies ITtscLintConfig;
 ```

package/linthost/print_nodes_array.go

@@ -32,9 +32,11 @@ func printArrayLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   // A comment between elements (or after `[`) would be dropped by the fresh
-  // separators; bail to verbatim so the enclosing reflow abstains.
+  // separators; bail to verbatim and report UNCOVERED (hard `false`, not
+  // `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim array and moving it off its line.
   if listHasInterItemComments(ctx, node) {
-    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    return verbatim(ctx, node), false
   }
   items := make([]Doc, 0, len(arr.Elements.Nodes))
   covered := true
@@ -119,12 +121,68 @@ func arrayForcesBreak(node *shimast.Node) bool {
   return arrayShouldForceBreak(arr.Elements.Nodes)
 }
 
+// fastPathForcesBreak reports whether `node`, OR a force-breaking node nested
+// within the subtree a reflow of `node` would print (its call/new arguments and
+// array elements, recursively), must explode even though it fits flat. Prettier
+// breaks such a descendant — an array `shouldBreak` or a function-composition
+// call/new — when the enclosing node reflows; ttsc's print-width fast path
+// returns first while the descendant abstains via hasReflowAncestor, leaving
+// both flat (`new Map([["a", 1], ["b", 2]])`, `foo([[1, 2], [3, 4]])`). So the
+// fast path must consult this, not only the visited node itself.
+func fastPathForcesBreak(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  if callForcesFunctionBreak(node) || arrayForcesBreak(node) {
+    return true
+  }
+  var children []*shimast.Node
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil && c.Arguments != nil {
+      children = c.Arguments.Nodes
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil && n.Arguments != nil {
+      children = n.Arguments.Nodes
+    }
+  case shimast.KindArrayLiteralExpression:
+    if a := node.AsArrayLiteralExpression(); a != nil && a.Elements != nil {
+      children = a.Elements.Nodes
+    }
+  case shimast.KindObjectLiteralExpression:
+    // A force-breaking array/object nested in an object PROPERTY value
+    // (`{ m: [[1, 2], [3, 4]] }`) must also deny the fast path: the value
+    // abstains to its object ancestor via hasReflowAncestor, and the object
+    // itself fits flat, so without descending into property initializers both
+    // would stay flat where Prettier breaks them.
+    if o := node.AsObjectLiteralExpression(); o != nil && o.Properties != nil {
+      for _, p := range o.Properties.Nodes {
+        if p != nil && p.Kind == shimast.KindPropertyAssignment {
+          if pa := p.AsPropertyAssignment(); pa != nil && pa.Initializer != nil {
+            children = append(children, pa.Initializer)
+          }
+        }
+      }
+    }
+  }
+  for _, ch := range children {
+    if fastPathForcesBreak(ch) {
+      return true
+    }
+  }
+  return false
+}
+
 // isConciselyPrintedArray reports whether an array should use Prettier's
-// concise "fill" layout: more than one element and every element a numeric
+// concise "fill" layout: at least one element and every element a numeric
 // literal (optionally a `+`/`-` signed numeric). Prettier packs such arrays
 // several per line; mixed / string / identifier arrays stay one-per-line.
+// Prettier's predicate gates on `elements.length > 0` (array.js), so a
+// single-element numeric array counts — which also makes a `[42]` last
+// argument decline last-argument hugging, matching shouldExpandLastArg.
 func isConciselyPrintedArray(elems []*shimast.Node) bool {
-  if len(elems) < 2 {
+  if len(elems) < 1 {
     return false
   }
   for _, e := range elems {
@@ -136,13 +194,15 @@ func isConciselyPrintedArray(elems []*shimast.Node) bool {
 }
 
 // isNumericArrayElement reports whether `node` is a numeric literal or a
-// `+`/`-` prefix applied to one.
+// `+`/`-` prefix applied to one. A BigInt literal is NOT numeric here: Prettier's
+// isNumericLiteral matches only a number-valued literal, so `[1n, 2n]` prints
+// one element per line rather than filling.
 func isNumericArrayElement(node *shimast.Node) bool {
   if node == nil {
     return false
   }
   switch node.Kind {
-  case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+  case shimast.KindNumericLiteral:
     return true
   case shimast.KindPrefixUnaryExpression:
     u := node.AsPrefixUnaryExpression()
@@ -152,8 +212,7 @@ func isNumericArrayElement(node *shimast.Node) bool {
     if u.Operator != shimast.KindPlusToken && u.Operator != shimast.KindMinusToken {
       return false
     }
-    return u.Operand.Kind == shimast.KindNumericLiteral ||
-      u.Operand.Kind == shimast.KindBigIntLiteral
+    return u.Operand.Kind == shimast.KindNumericLiteral
   }
   return false
 }

package/linthost/print_nodes_call.go

@@ -2,7 +2,6 @@ package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // printCallExpression renders a CallExpression with width-aware
@@ -52,6 +51,18 @@ func printCallExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if hasNilEntry(call.Arguments) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment in an argument gap (`foo(a, /* c */ b)`) would be dropped by the
+  // freshly minted `, ` separators in printArgList. The top-level print-width
+  // scan only masks a *direct* child's comments, so a comment inside a NESTED
+  // call's argument list slips through and is lost on reflow. Self-guard the
+  // way the object/array printers do: bail to verbatim and report UNCOVERED so
+  // an enclosing reflow abstains too. Uncovered must be hard `false`, not
+  // `!nodeSpansMultipleLines`: a single-line comment-bearing call would
+  // otherwise report covered and let the outer reflow break around it, moving
+  // the verbatim node off its line (the assertFormatUnchanged contract).
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   // Prettier never appends a trailing comma inside a dynamic
   // `import(...)`, so the printer's reflow must agree with
   // format/trailing-comma's same exception (see isDynamicImportCall).
@@ -90,6 +101,16 @@ func printNewExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if ne.TypeArguments != nil {
     parts = append(parts, verbatimRange(ctx.Source, typeArgsStart(ctx.Source, ne.TypeArguments), typeArgsEnd(ctx.Source, ne.TypeArguments)))
   }
+  // A comment in the `new`->constructee gap (`new /* c */ Foo`) or an argument
+  // gap would be dropped by the minted `Text("new ")` / fresh separators — those
+  // gaps are not AST children, so a nested new-expression's comment slips past
+  // the top-level scan. Guard unconditionally (the no-args `new Foo` path mints
+  // `new ` too), mirroring printCallExpression's unconditional guard. Report
+  // UNCOVERED (hard `false`, not `!nodeSpansMultipleLines`) so an enclosing
+  // reflow abstains rather than breaking around this single-line verbatim node.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   if ne.Arguments != nil {
     if hasNilEntry(ne.Arguments) {
       return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
@@ -155,13 +176,17 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, deco
   // doc carries hard breaks (a block-bodied callback). A leading object or
   // array that merely fits flat does NOT decline — Prettier still hugs the
   // last argument there (`doConfigure({ … }, () => { … })`).
-  // A decorator's call hugs its last argument even past leading callbacks
-  // (`@OneToMany(() => P, (p) => p.c, { … })` keeps the arrows inline and
-  // breaks only the object); a plain call with two or more leading callbacks
-  // explodes instead, so the function-arg gate applies only off a decorator.
+  // The useMemo/useEffect deps shape (`f(() => x, [deps])`) explodes its 2-arg
+  // arrow+array one-per-line even under a decorator: Prettier's shouldExpandLastArg
+  // declines `args.length === 2 && penultimate is ArrowFunction && last is Array`
+  // unconditionally (it is NOT decorator-gated). The genuine decorator hug
+  // (`@OneToMany(() => P, (p) => p.c, { … })`) is 3-arg, so isUseMemoArrowArrayShape
+  // already returns false for it; a 2-or-more-callback composition is handled by
+  // argListForcesFunctionBreak, and a block-bodied leading callback by
+  // anyLeadingItemBreaks.
   hugLast := shouldHugLastArgument(list.Nodes) &&
     !anyLeadingItemBreaks(items) &&
-    (decoratorCall || !anyLeadingArgIsFunctionLike(list.Nodes))
+    !isUseMemoArrowArrayShape(list.Nodes)
   // Two or more function/arrow arguments force the list to explode, one per
   // line, even when it would fit flat: Prettier always breaks a call carrying
   // multiple callbacks (`promise.then(() => a, () => b)`), the
@@ -180,6 +205,7 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, deco
     hugLast = true
     forceFnBreak = false
   }
+  hugFirst := !hugLast && !forceFnBreak && shouldHugFirstArgument(ctx, list.Nodes)
   shape := listShape{
     OpenTok:      "(",
     CloseTok:     ")",
@@ -188,9 +214,16 @@ func printArgList(ctx *PrintContext, list *shimast.NodeList, addComma bool, deco
     AddComma:     addComma,
     HugLast:      hugLast,
     HugLastForce: forceHugLast,
-    HugFirst:     !hugLast && !forceFnBreak && shouldHugFirstArgument(ctx, list.Nodes),
-    ForceBreak:   forceFnBreak,
-    BlankBefore:  blankBeforeItems(ctx.Source, list.Nodes),
+    HugFirst:     hugFirst,
+    // A non-empty array second argument reaches HugFirst only via the
+    // React-hook deps branch of shouldHugFirstArgument; let that deps array
+    // break one-per-line instead of being pinned flat on the close line.
+    HugFirstTrailingBreaks: hugFirst && len(list.Nodes) == 2 &&
+      list.Nodes[1] != nil &&
+      list.Nodes[1].Kind == shimast.KindArrayLiteralExpression,
+    HugFirstForce: hugFirst && isReactHookDepsCall(list.Nodes),
+    ForceBreak:    forceFnBreak,
+    BlankBefore:   blankBeforeItems(ctx.Source, list.Nodes),
   }
   return printList(ctx, shape), covered
 }
@@ -379,40 +412,78 @@ func argListForcesFunctionBreak(args []*shimast.Node, decoratorCall bool) bool {
   return isFunctionCompositionArgs(args)
 }
 
-// callForcesFunctionBreak reports whether a node is a CallExpression that the
-// multiple-callback rule forces to explode. The print-width rule consults it
-// so its flat-fit fast path does not leave such a call inline when the source
+// callForcesFunctionBreak reports whether a node is a call OR new expression
+// that the multiple-callback rule forces to explode. Prettier's printCallArguments
+// is shared by NewExpression (its function-composition break is gated only by
+// `path.parent.type !== "Decorator"`, not by call-vs-new), so `new Foo(() => a,
+// () => b)` explodes the same as a call. The print-width rule consults this so
+// its flat-fit fast path does not leave such a call/new inline when the source
 // wrote it on one line.
 func callForcesFunctionBreak(node *shimast.Node) bool {
-  if node == nil || node.Kind != shimast.KindCallExpression {
+  if node == nil {
     return false
   }
-  call := node.AsCallExpression()
-  if call == nil || call.Arguments == nil {
+  var args *shimast.NodeList
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil {
+      args = c.Arguments
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil {
+      args = n.Arguments
+    }
+  default:
     return false
   }
-  decoratorCall := node.Parent != nil && node.Parent.Kind == shimast.KindDecorator
-  return argListForcesFunctionBreak(call.Arguments.Nodes, decoratorCall)
+  if args == nil {
+    return false
+  }
+  // A new expression is never a decorator's call.
+  decoratorCall := node.Kind == shimast.KindCallExpression &&
+    node.Parent != nil && node.Parent.Kind == shimast.KindDecorator
+  return argListForcesFunctionBreak(args.Nodes, decoratorCall)
 }
 
-// anyLeadingArgIsFunctionLike reports whether any argument before the last
-// is a function or arrow expression. Prettier declines last-argument
-// hugging when a non-last argument is itself a function/arrow, regardless
-// of its body, so `useMemo(() => compute(), [deps])` explodes rather than
-// hugging the trailing array. This complements anyLeadingItemBreaks, which
-// only catches leads with hard line breaks (a block body) and so misses an
-// expression-bodied arrow.
-func anyLeadingArgIsFunctionLike(args []*shimast.Node) bool {
-  for i := 0; i+1 < len(args); i++ {
-    if args[i] == nil {
-      continue
-    }
-    switch args[i].Kind {
-    case shimast.KindArrowFunction, shimast.KindFunctionExpression:
-      return true
-    }
+// isUseMemoArrowArrayShape reports the ONE leading-argument shape Prettier
+// declines last-argument hugging for: exactly two arguments where the first is
+// an arrow function and the last is an array literal — the
+// `useMemo(() => x, [deps])` / `useEffect(() => { … }, [deps])` shape.
+// Prettier's shouldExpandLastArg (call-arguments.js:260-262) has NO general
+// "a leading function declines hugging" rule; its only leading-argument clause
+// is `args.length === 2 && penultimate is ArrowFunctionExpression && last is
+// ArrayExpression`. A block-bodied leading callback is handled independently by
+// anyLeadingItemBreaks (it `willBreak`), and two-or-more callbacks by
+// argListForcesFunctionBreak, so a leading expression-bodied arrow before a
+// non-array huggable last argument (`f((x) => g(x), { a: 1 })`) must still hug.
+func isUseMemoArrowArrayShape(args []*shimast.Node) bool {
+  if len(args) != 2 || args[0] == nil || args[1] == nil {
+    return false
   }
-  return false
+  return args[0].Kind == shimast.KindArrowFunction &&
+    args[1].Kind == shimast.KindArrayLiteralExpression
+}
+
+// isReactHookDepsCall reports the React-hook deps shape Prettier hugs WITHOUT an
+// exploded fallback: exactly two arguments, the first a ZERO-parameter
+// block-bodied arrow, the second an array literal (`useEffect(() => { … },
+// [deps])`). Prettier's isReactHookCallWithDepsArray / isValidHookCallbackAndDepsFormat
+// keys on this and never explodes the args — it keeps the callback hugged and
+// lets the open line overflow. A parameterized callback (`subscribe((e) => { … },
+// [])`) is NOT this shape and keeps the fallback, so the zero-parameter +
+// block-body gate is load-bearing (distinct from isUseMemoArrowArrayShape and
+// from the HugFirstTrailingBreaks array check).
+func isReactHookDepsCall(args []*shimast.Node) bool {
+  if len(args) != 2 || args[0] == nil || args[1] == nil {
+    return false
+  }
+  if args[1].Kind != shimast.KindArrayLiteralExpression {
+    return false
+  }
+  arrow := args[0].AsArrowFunction()
+  return arrow != nil && arrow.Body != nil &&
+    arrow.Body.Kind == shimast.KindBlock &&
+    len(args[0].Parameters()) == 0
 }
 
 // anyLeadingItemBreaks reports whether any item before the last carries a
@@ -460,6 +531,15 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
     if pen := args[len(args)-2]; pen != nil && pen.Kind == last.Kind {
       return false
     }
+    // Prettier's shouldExpandLastArg also declines a CONCISELY-PRINTED numeric
+    // array as the last of two-plus arguments: it fills on its own line, so
+    // `drawPolygon(ctx, [1, 2, 3, …])` explodes rather than hugging.
+    if last.Kind == shimast.KindArrayLiteralExpression {
+      if arr := last.AsArrayLiteralExpression(); arr != nil && arr.Elements != nil &&
+        isConciselyPrintedArray(arr.Elements.Nodes) {
+        return false
+      }
+    }
   }
   return true
 }
@@ -471,10 +551,23 @@ func shouldHugLastArgument(args []*shimast.Node) bool {
 // flat hugging Concat would pin an overflowing call to one line.
 func lastArgHuggableShape(last *shimast.Node) bool {
   switch last.Kind {
-  case shimast.KindFunctionExpression,
-    shimast.KindObjectLiteralExpression,
-    shimast.KindArrayLiteralExpression:
+  case shimast.KindFunctionExpression:
     return true
+  case shimast.KindObjectLiteralExpression:
+    // Prettier's couldExpandArg requires a NON-EMPTY object (`properties.length
+    // > 0`); an empty `{}` is not expandable, so `foo(a, b, {})` explodes the
+    // list rather than hugging. (Inter-item comments route to verbatim, so the
+    // hasComment branch is moot here.)
+    if obj := last.AsObjectLiteralExpression(); obj != nil {
+      return obj.Properties != nil && len(obj.Properties.Nodes) > 0
+    }
+    return false
+  case shimast.KindArrayLiteralExpression:
+    // Likewise a non-empty array; an empty `[]` is not expandable.
+    if arr := last.AsArrayLiteralExpression(); arr != nil {
+      return arr.Elements != nil && len(arr.Elements.Nodes) > 0
+    }
+    return false
   case shimast.KindArrowFunction:
     arrow := last.AsArrowFunction()
     if arrow == nil || arrow.Body == nil {
@@ -494,13 +587,26 @@ func lastArgHuggableShape(last *shimast.Node) bool {
       return true
     case shimast.KindObjectLiteralExpression,
       shimast.KindArrayLiteralExpression:
-      // An expression-bodied arrow with an explicit return type is not hugged:
-      // Prettier's couldGroupArg excludes it ("avoid breaking inside composite
-      // return types"), so `map((r): T => ({ … }))` explodes the whole list
-      // while `map((r) => ({ … }))` hugs.
-      return arrow.Type == nil
+      // An object/array-bodied arrow hugs unless its return type is a type
+      // REFERENCE. Prettier's couldExpandArg gates only on
+      // `returnType.typeAnnotation.type === "TSTypeReference"`, so a keyword,
+      // union, array, or literal return type (`map((r): void => ({ … }))`)
+      // still hugs while a named-reference return (`map((r): Foo => ({ … })))`)
+      // explodes the whole list. A block body hugs regardless (handled above).
+      return arrow.Type == nil || arrow.Type.Kind != shimast.KindTypeReference
     }
   }
+  // DEFERRED (architectural, not a one-line predicate fix; do not re-add to the
+  // switch above without the supporting layout work):
+  //   - A call/conditional/JSX-expression arrow body. Prettier's couldExpandArg
+  //     hugs it, but ttsc emits the arrow signature (`=> `) verbatim with no
+  //     break point after `=>`, so hugging here would force the FIRST group
+  //     inside the call instead of breaking after `=>` — a different shape, not
+  //     parity. Needs a break-after-`=>` arrow-body layout variant first.
+  //   - A trailing `as`/`satisfies` cast wrapping a huggable last argument.
+  //     Prettier's couldExpandArg recurses into the cast, but ttsc does not
+  //     dispatch KindAsExpression (it prints verbatim), so forceBreakFirstGroup
+  //     finds no group and the hug is inert. Needs a cast printer first.
   return false
 }
 
@@ -523,7 +629,22 @@ func shouldHugFirstArgument(ctx *PrintContext, args []*shimast.Node) bool {
   if first == nil || second == nil {
     return false
   }
-  return isFirstArgHuggableCallback(first) && isSimpleTrailingArg(ctx, second)
+  if !isFirstArgHuggableCallback(first) {
+    return false
+  }
+  // A NON-EMPTY array trailing arg hugs only in Prettier's React-hook deps
+  // shape (isReactHookCallWithDepsArray): a ZERO-parameter arrow callback plus
+  // an array, e.g. `useEffect(() => { … }, [a, b])`. With a parameter the call
+  // explodes (`subscribe((event) => { … }, [a, b])`), and a function expression
+  // (not an arrow) never qualifies. An EMPTY array falls through to
+  // isSimpleTrailingArg.
+  if second.Kind == shimast.KindArrayLiteralExpression {
+    if arr := second.AsArrayLiteralExpression(); arr != nil &&
+      arr.Elements != nil && len(arr.Elements.Nodes) > 0 {
+      return first.Kind == shimast.KindArrowFunction && len(first.Parameters()) == 0
+    }
+  }
+  return isSimpleTrailingArg(ctx, second)
 }
 
 // isFirstArgHuggableCallback reports whether `node` is the callback shape
@@ -544,18 +665,18 @@ func isFirstArgHuggableCallback(node *shimast.Node) bool {
 // isSimpleTrailingArg reports whether `node` is a value that may trail a
 // hugged first-argument callback. Prettier hugs the leading callback when
 // the trailing argument is an identifier, member access, literal, `this`,
-// or an array literal — most notably the `useEffect(() => { … }, [deps])`
-// idiom. It also accepts an empty object literal, a short call/new, and a
-// short arithmetic/logical expression (`setTimeout(fn, 1000 - x)`). A function,
-// arrow, conditional, or a non-empty object literal is excluded so
-// first-argument hugging declines and the whole list explodes.
+// or an EMPTY array/object literal. It also accepts a short call/new (at
+// most one value argument) and a short arithmetic/logical expression
+// (`setTimeout(fn, 1000 - x)`). A function, arrow, conditional, a non-empty
+// array, or a non-empty object literal is excluded, so first-argument hugging
+// declines and the whole list explodes. (A non-empty array after a
+// zero-parameter arrow is the React-hook deps shape, hugged earlier in
+// shouldHugFirstArgument and never routed here.)
 //
-// A call expression is deliberately NOT included: the conditional-group
-// fit check only measures an option's first line, so a hugged-first option
-// whose trailing call overflows the closing line (`}, deeplyNested(…))`)
-// would still be selected, where Prettier explodes. The array case shares
-// that limitation in principle, but dependency arrays are short in
-// practice, the same way the identifier/member cases already are.
+// The call/new case rides the close line: the conditional-group fit check
+// only measures an option's first line, so a hugged-first option whose
+// trailing call overflows the closing line is still selected. Prettier
+// accepts the same trade for a short trailing call.
 func isSimpleTrailingArg(ctx *PrintContext, node *shimast.Node) bool {
   switch node.Kind {
   case shimast.KindIdentifier,
@@ -567,26 +688,46 @@ func isSimpleTrailingArg(ctx *PrintContext, node *shimast.Node) bool {
     shimast.KindNullKeyword,
     shimast.KindThisKeyword,
     shimast.KindPropertyAccessExpression,
-    shimast.KindElementAccessExpression,
-    shimast.KindArrayLiteralExpression:
+    shimast.KindElementAccessExpression:
     return true
+  case shimast.KindArrayLiteralExpression:
+    // Only an EMPTY array is simple-trailing (the `[] as T[]` cast idiom).
+    // Prettier's couldExpandArg treats an array with elements as expandable,
+    // so a non-empty array cast (`[x] as number[]`) explodes the list rather
+    // than hugging. The non-empty bare-array deps shape (zero-param arrow) is
+    // handled in shouldHugFirstArgument before reaching here.
+    if arr := node.AsArrayLiteralExpression(); arr != nil {
+      return arr.Elements == nil || len(arr.Elements.Nodes) == 0
+    }
+    return false
   case shimast.KindAsExpression:
     // `[] as string[]`: the `reduce(fn, [] as T[])` idiom. Hug when the cast
-    // wraps a value that is itself a simple trailing arg AND the target type is
-    // simple. A type carrying an object type literal (`[] as Array<{ … }>`) is
-    // not simple, Prettier expands and explodes the list there, so exclude any
-    // type whose source contains a `{` (a type literal).
+    // target is a simple type AND its inner expression is simple at depth 1 —
+    // Prettier's isHopefullyShortCallArgument cast branch is exactly
+    // `isSimpleType(typeAnnotation) && isSimpleCallArgument(node.expression, 1)`.
+    // Depth 1 (not the general isSimpleTrailingArg) is deliberate: it has no
+    // binaryish branch and bottoms a nested call's argument out at depth 0, so
+    // `(a - b) as T` and `makeInit(x) as T[]` are NOT simple and explode.
     if as := node.AsAsExpression(); as != nil && as.Expression != nil {
-      return isSimpleTrailingArg(ctx, as.Expression) && !typeHasObjectLiteral(ctx.Source, as.Type)
+      return isSimpleCallArg(as.Expression, 1) && isSimpleCastType(as.Type)
+    }
+  case shimast.KindSatisfiesExpression:
+    // `[] satisfies T[]`: Prettier's isBinaryCastExpression covers
+    // TSSatisfiesExpression identically to TSAsExpression, so a satisfies cast
+    // takes the same simple-type + depth-1 simple-expression path as `as`.
+    if s := node.AsSatisfiesExpression(); s != nil && s.Expression != nil {
+      return isSimpleCallArg(s.Expression, 1) && isSimpleCastType(s.Type)
     }
   case shimast.KindCallExpression, shimast.KindNewExpression:
     // `reduce(fn, Object.create(null))` / `reduce(fn, new Map<…>())`: Prettier
-    // hugs the first arg when the trailing call/new has at most one value
-    // argument, regardless of its length, type arguments and long names do not
-    // matter and the close line is allowed to overflow. A call with two or more
-    // arguments explodes the whole list instead. Mirrors Prettier's
-    // isHopefullyShortCallArgument for call-like nodes.
-    return callValueArgCount(node) <= 1
+    // hugs the first arg over a trailing call/new only when it has at most one
+    // value argument AND that argument is itself structurally simple. Its
+    // isHopefullyShortCallArgument early-rejects >1 args, then falls through to
+    // isSimpleCallArgument (depth 2), so a 1-arg call whose sole argument is a
+    // non-trivial nested call/object/array (`reduce(fn, makeInit(deep(arg)))`)
+    // is NOT simple and the whole list explodes. Type arguments and long names
+    // still do not matter; the close line is allowed to overflow.
+    return callValueArgCount(node) <= 1 && isSimpleCallArg(node, 2)
   case shimast.KindObjectLiteralExpression:
     // `reduce(fn, {})`: an EMPTY object literal hugs (Prettier's couldGroupArg
     // excludes a property-less object); an object with properties expands and
@@ -612,6 +753,109 @@ func isSimpleTrailingArg(ctx *PrintContext, node *shimast.Node) bool {
   return false
 }
 
+// isSimpleCallArg ports Prettier's isSimpleCallArgument (utilities/index.js): a
+// depth-bounded structural simplicity check. A node is simple when it is a leaf
+// (identifier, literal, this, member access) or a shallow composite whose parts
+// are simple at a reduced depth — a call/new is simple only when its callee is
+// simple, it has at most `depth` arguments, and every argument is simple at
+// `depth-1`. The recursion floor (`depth <= 0`) is what makes a nested call
+// like `makeInit(deep(arg))` non-simple, so first-argument hugging declines and
+// the list explodes, matching Prettier. A non-empty object is treated as
+// non-simple (its values bottom out below the depth floor anyway — the safe
+// under-match direction). Element access is treated as a simple leaf, matching
+// ttsc's existing member-access handling, rather than recursing into its
+// computed key (a pre-existing, rare residual over-match left out of scope).
+func isSimpleCallArg(node *shimast.Node, depth int) bool {
+  if node == nil || depth <= 0 {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier,
+    shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindThisKeyword,
+    shimast.KindElementAccessExpression:
+    return true
+  case shimast.KindParenthesizedExpression:
+    if p := node.AsParenthesizedExpression(); p != nil {
+      return isSimpleCallArg(p.Expression, depth)
+    }
+  case shimast.KindNonNullExpression:
+    // Prettier's isSimpleCallArgument unwraps TSNonNullExpression at the same
+    // depth, so `foo!()` / `target!` recurse into the asserted expression.
+    if n := node.AsNonNullExpression(); n != nil {
+      return isSimpleCallArg(n.Expression, depth)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    if u := node.AsPrefixUnaryExpression(); u != nil {
+      return isSimpleCallArg(u.Operand, depth)
+    }
+  case shimast.KindPropertyAccessExpression:
+    // The `.name` half is an identifier (trivially simple); recurse the object
+    // so `a.b(x, y).c` (a member of a multi-argument call) is correctly not
+    // simple, matching Prettier's member recursion.
+    if m := node.AsPropertyAccessExpression(); m != nil {
+      return isSimpleCallArg(m.Expression, depth)
+    }
+  case shimast.KindArrayLiteralExpression:
+    if arr := node.AsArrayLiteralExpression(); arr != nil {
+      if arr.Elements == nil {
+        return true
+      }
+      for _, el := range arr.Elements.Nodes {
+        if !isSimpleCallArg(el, depth-1) {
+          return false
+        }
+      }
+      return true
+    }
+  case shimast.KindObjectLiteralExpression:
+    // Only an empty object is treated as simple. A non-empty object's values
+    // are checked at depth-1, which bottoms out to false at every depth that
+    // occurs as a trailing-call argument, so declining one never over-matches.
+    if obj := node.AsObjectLiteralExpression(); obj != nil {
+      return obj.Properties == nil || len(obj.Properties.Nodes) == 0
+    }
+  case shimast.KindCallExpression:
+    if c := node.AsCallExpression(); c != nil {
+      var args []*shimast.Node
+      if c.Arguments != nil {
+        args = c.Arguments.Nodes
+      }
+      if !isSimpleCallArg(c.Expression, depth) || len(args) > depth {
+        return false
+      }
+      for _, a := range args {
+        if !isSimpleCallArg(a, depth-1) {
+          return false
+        }
+      }
+      return true
+    }
+  case shimast.KindNewExpression:
+    if n := node.AsNewExpression(); n != nil {
+      var args []*shimast.Node
+      if n.Arguments != nil {
+        args = n.Arguments.Nodes
+      }
+      if !isSimpleCallArg(n.Expression, depth) || len(args) > depth {
+        return false
+      }
+      for _, a := range args {
+        if !isSimpleCallArg(a, depth-1) {
+          return false
+        }
+      }
+      return true
+    }
+  }
+  return false
+}
+
 // isSimpleBinaryOperand reports whether a node is a short, non-recursive
 // operand, an identifier, a literal, `this`, or a member access. A binary,
 // call, conditional, or other compound expression is not, so a binary built
@@ -636,24 +880,48 @@ func isSimpleBinaryOperand(node *shimast.Node) bool {
   return false
 }
 
-// typeHasObjectLiteral reports whether a type node's source contains a `{`,
-// the mark of an object type literal (`{ a: 1 }`, `Array<{ … }>`). Prettier's
-// isSimpleType rejects such a type; a flat type (`string[]`, `Foo<Bar>`,
-// `number[][]`) has none and stays simple.
-func typeHasObjectLiteral(src string, typeNode *shimast.Node) bool {
-  if typeNode == nil {
-    return false
-  }
-  start := shimscanner.SkipTrivia(src, typeNode.Pos())
-  end := typeNode.End()
-  if start < 0 || end < start || end > len(src) {
-    return true // unmeasurable: be conservative and decline the hug
+// isSimpleCastType ports the type half of Prettier's isHopefullyShortCallArgument
+// cast branch: unwrap an array type up to two levels (`T[]`, `T[][]` -> `T`) and
+// a single-type-argument reference (`Ref<X>` -> `X`), then require a SIMPLE type
+// (isSimpleTypeNode). A reference still carrying type arguments after the unwrap
+// (`Foo<A, B>`, `Array<Array<string>>`), or a union / intersection / function /
+// tuple / object type, is not simple, so the cast declines the first-argument
+// hug and the list explodes, matching Prettier.
+func isSimpleCastType(typeNode *shimast.Node) bool {
+  node := typeNode
+  for i := 0; i < 2 && node != nil && node.Kind == shimast.KindArrayType; i++ {
+    at := node.AsArrayTypeNode()
+    if at == nil || at.ElementType == nil {
+      return false
+    }
+    node = at.ElementType
   }
-  for i := start; i < end; i++ {
-    if src[i] == '{' {
-      return true
+  if node != nil && node.Kind == shimast.KindTypeReference {
+    if ref := node.AsTypeReferenceNode(); ref != nil && ref.TypeArguments != nil &&
+      len(ref.TypeArguments.Nodes) == 1 {
+      node = ref.TypeArguments.Nodes[0]
     }
   }
+  return isSimpleTypeNode(node)
+}
+
+// isSimpleTypeNode mirrors Prettier's isSimpleType: a keyword/primitive type, a
+// literal type, `this`, or a bare type reference with NO type arguments.
+func isSimpleTypeNode(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringKeyword, shimast.KindNumberKeyword, shimast.KindBooleanKeyword,
+    shimast.KindAnyKeyword, shimast.KindUnknownKeyword, shimast.KindVoidKeyword,
+    shimast.KindNeverKeyword, shimast.KindUndefinedKeyword, shimast.KindNullKeyword,
+    shimast.KindObjectKeyword, shimast.KindSymbolKeyword, shimast.KindBigIntKeyword,
+    shimast.KindThisType, shimast.KindLiteralType, shimast.KindTemplateLiteralType:
+    return true
+  case shimast.KindTypeReference:
+    ref := node.AsTypeReferenceNode()
+    return ref != nil && (ref.TypeArguments == nil || len(ref.TypeArguments.Nodes) == 0)
+  }
   return false
 }
 

package/linthost/print_nodes_function.go

@@ -113,6 +113,16 @@ func printParenthesizedExpression(ctx *PrintContext, node *shimast.Node) (Doc, b
   if paren == nil || paren.Expression == nil {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment around the parens (`(/* c */ x)`, `(x /* c */)`) would be dropped
+  // by the minted `(`/`)` — the parens are not AST children, so a nested
+  // ParenthesizedExpression's gap comment slips past the top-level print-width
+  // scan and is lost on reflow. Bail to verbatim and report UNCOVERED (hard
+  // `false`, not `!nodeSpansMultipleLines`) so an enclosing reflow abstains
+  // instead of breaking around this single-line verbatim paren, like the
+  // object/array/call printers.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   inner, covered := PrintNode(ctx, paren.Expression)
   return Concat(Text("("), inner, Text(")")), covered
 }
@@ -344,6 +354,14 @@ func printReturnStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
+  // A comment between `return` and its argument (`return /* c */ x`) lives in
+  // the argument's leading trivia and would be dropped by the minted
+  // `Text("return ")` — the gap is not an AST child, and a return statement is
+  // only reached as a nested child of a block, so the outer print-width and
+  // block scans mask it. Bail to verbatim (uncovered) like the round-7 printers.
+  if gapHasComment(ctx.Source, stmt.Expression.Pos(), shimscanner.SkipTrivia(ctx.Source, stmt.Expression.Pos())) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
   exprDoc, covered := PrintNode(ctx, stmt.Expression)
   parts := []Doc{Text("return "), exprDoc}
   if sourceHasStatementTerminator(ctx.Source, node.End()) {

package/linthost/print_nodes_imports.go

@@ -2,6 +2,7 @@ package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // printNamedImports renders `{ a, b, c }` inside an import declaration.
@@ -142,9 +143,25 @@ func printImportDeclaration(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   // prefix forms are exclusive.
   prefix := "import "
   if clause.IsTypeOnly() {
+    // A comment in the `type`->`{` gap (`import type /* c */ { … }`) would be
+    // dropped by the minted prefix. The `type` keyword is a clause modifier
+    // flag, not a child node, so the top-level scan masks it (it sits inside the
+    // ImportClause span) and the `nb`-scoped guard starts at `{`. Bail to
+    // verbatim, like the default-binding gap below.
+    if gapHasComment(ctx.Source, shimscanner.SkipTrivia(ctx.Source, clause.Pos()), shimscanner.SkipTrivia(ctx.Source, nb.Pos())) {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
     prefix = "import type "
   }
   if name := clause.Name(); name != nil {
+    // A comment in the default-binding-to-brace gap (`import D /* c */, { … }`)
+    // would be dropped by the minted `, ` prefix. That gap is not a direct child
+    // of the import node, so the top-level scan masks it and the `nb`-scoped
+    // guard above starts at `{` — same class as printReturnStatement's leading
+    // gap. Bail to verbatim.
+    if gapHasComment(ctx.Source, name.End(), shimscanner.SkipTrivia(ctx.Source, nb.Pos())) {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
     prefix = "import " + identifierText(name) + ", "
   }
 

package/linthost/print_nodes_list.go

@@ -66,6 +66,22 @@ type listShape struct {
   // `callback, simpleArg` shape Prettier hugs (`foo(() => { … }, x)`).
   // HugLast and HugFirst are mutually exclusive.
   HugFirst bool
+  // HugFirstTrailingBreaks tells printListHuggingFirst NOT to flatten the
+  // trailing item, letting it render through its own breakable group. The
+  // call-argument printer sets it for the React-hook deps shape
+  // (`useEffect(() => { … }, [deps])`), whose deps array Prettier breaks
+  // one-element-per-line when it overflows rather than pinning it flat on the
+  // close line. The short leaf/call trailing args of every other first-arg-hug
+  // case still flatten (they ride the close line flat, per Prettier).
+  HugFirstTrailingBreaks bool
+  // HugFirstForce drops the exploded fallback from a HugFirst list, the mirror
+  // of HugLastForce. The call-argument printer sets it for a genuine React-hook
+  // deps call (`useEffect(() => { … }, [deps])`: a zero-parameter block-bodied
+  // arrow plus an array literal), which Prettier's isReactHookCallWithDepsArray
+  // path never explodes — it keeps the callback hugged and lets the open line
+  // overflow. Distinct from HugFirstTrailingBreaks, which also fires for a
+  // parameterized callback whose empty-array second arg DOES keep the fallback.
+  HugFirstForce bool
   // HugLastForce drops the exploded fallback from a HugLast list: the hugged
   // shape is chosen even when its opening line overflows printWidth. The
   // call-argument printer sets it for a test-framework call
@@ -153,10 +169,12 @@ func printList(ctx *PrintContext, shape listShape) Doc {
   if shape.HugFirst {
     hugged = printListHuggingFirst(ctx, shape)
   }
-  // A test-framework call hugs its callback unconditionally — Prettier never
-  // explodes its arguments — so drop the exploded fallback. The all-flat
-  // option still wins when the whole call fits (an empty-body callback).
-  if shape.HugLastForce {
+  // A test-framework call (HugLastForce) and a genuine React-hook deps call
+  // (HugFirstForce, `useEffect(() => { … }, [deps])`) hug their callback
+  // unconditionally — Prettier never explodes their arguments, it lets the open
+  // line overflow — so drop the exploded fallback. The all-flat option still
+  // wins when the whole call fits (an empty-body callback).
+  if shape.HugLastForce || shape.HugFirstForce {
     if allFlat, ok := flatten(plain); ok {
       return ConditionalGroup(allFlat, hugged)
     }
@@ -317,9 +335,14 @@ func printListHuggingFirst(ctx *PrintContext, shape listShape) Doc {
     // The trailing simple arguments ride the close line flat — Prettier keeps
     // them on one line even when that line overflows (a long zero/one-argument
     // trailing call `}, makeAccumulator(single))` is not broken). Force each
-    // flat so its own Group does not break against the close-line width.
-    if flat, ok := flatten(item); ok {
-      item = flat
+    // flat so its own Group does not break against the close-line width. The
+    // React-hook deps array is the exception (HugFirstTrailingBreaks): Prettier
+    // renders it through a breakable group, so leave it unflattened to break
+    // one-element-per-line when the close line overflows.
+    if !shape.HugFirstTrailingBreaks {
+      if flat, ok := flatten(item); ok {
+        item = flat
+      }
     }
     parts = append(parts, Text(", "), item)
   }

package/linthost/print_nodes_object.go

@@ -36,9 +36,11 @@ func printObjectLiteral(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
     return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   // A comment between properties (or after `{`) would be dropped by the fresh
-  // separators; bail to verbatim so the enclosing reflow abstains.
+  // separators; bail to verbatim and report UNCOVERED (hard `false`, not
+  // `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim object and moving it off its line.
   if listHasInterItemComments(ctx, node) {
-    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    return verbatim(ctx, node), false
   }
   items := make([]Doc, 0, len(obj.Properties.Nodes))
   covered := true

package/linthost/print_nodes_ternary.go

@@ -20,9 +20,11 @@ import (
 // (`a ? b : c ? d : e`) or every rung breaks onto its own line. Nesting
 // is expressed by recursing the chain builder without wrapping the
 // nested conditional in its own Group. The outermost chain indents its arms
-// by `tabWidth`, but each nested chain indents by a FIXED 2 columns (not
-// `tabWidth`), matching Prettier 3: at tabWidth 4 the outer arms sit at
-// column 4 and the nested arms at column 6, not 8.
+// by `tabWidth`. A nested chain in the ALTERNATE (`: `) position indents by a
+// fixed 2 columns; a nested chain in the CONSEQUENT (`? `) position indents by
+// `max(2, tabWidth)` (Prettier's extra `align(tabWidth-2)` on the consequent).
+// So at tabWidth 4 the outer arms sit at column 4, an alternate-nested arm at
+// column 6, and a consequent-nested arm at column 8; they coincide at tabWidth 2.
 //
 // The second return value is the coverage flag (see PrintNode): the AND
 // of the test and both branches, so a multi-line verbatim node anywhere
@@ -46,6 +48,16 @@ func buildConditionalChain(ctx *PrintContext, node *shimast.Node, indentCols int
   if cond == nil || cond.Condition == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
     return Doc{}, true
   }
+  // A comment around the `?`/`:` markers (`a ? /* c */ b : c`) would be dropped
+  // by the minted "? "/": " text — the markers are not AST children, so a
+  // nested conditional's gap comment slips past the top-level print-width scan
+  // and is lost on reflow. Bail to verbatim and report UNCOVERED (hard `false`,
+  // not `!nodeSpansMultipleLines`) so an enclosing reflow abstains instead of
+  // breaking around this single-line verbatim conditional and moving it off its
+  // line; the bytes survive.
+  if listHasInterItemComments(ctx, node) {
+    return verbatim(ctx, node), false
+  }
   testDoc, c1 := PrintNode(ctx, cond.Condition)
   consDoc, c2 := ternaryArm(ctx, cond.WhenTrue, true)
   altDoc, c3 := ternaryArm(ctx, cond.WhenFalse, false)
@@ -87,10 +99,39 @@ func buildConditionalChain(ctx *PrintContext, node *shimast.Node, indentCols int
 // the broken staircase. A nested conditional in the ALTERNATE (`: `) position
 // is never wrapped — it chains. `isConsequent` selects between the two.
 func ternaryArm(ctx *PrintContext, node *shimast.Node, isConsequent bool) (Doc, bool) {
-  if node != nil && node.Kind == shimast.KindConditionalExpression {
-    // A nested chain indents a fixed 2 columns past its parent rung,
-    // independent of tabWidth (Prettier 3's nested-ternary rule).
-    chain, covered := buildConditionalChain(ctx, node, 2)
+  inner := node
+  // A nested ternary written with explicit source parentheses — `a ? (b ? c : d)
+  // : e` — is the same chain link as a bare nested ternary: Prettier's AST has no
+  // ParenthesizedExpression node, so its `printTernary` sees the consequent as a
+  // ConditionalExpression and joins the staircase (re-adding the parens only in
+  // flat mode via ifBreak). Unwrap a parenthesized conditional so it chains too,
+  // instead of printing flat inside kept parens. Only a ConditionalExpression
+  // inner is unwrapped; `(a ?? b)` and other parenthesized expressions keep their
+  // parens through the normal printer.
+  // Do NOT unwrap when a comment sits between the parens and the inner
+  // conditional (`(/* keep */ b ? c : d)`): dropping the ParenExpr wrapper would
+  // delete that comment. Leaving `inner` as the ParenExpr routes it through the
+  // normal printer, whose own self-guard bails to verbatim and preserves it.
+  if inner != nil && inner.Kind == shimast.KindParenthesizedExpression &&
+    !listHasInterItemComments(ctx, inner) {
+    if p := inner.AsParenthesizedExpression(); p != nil && p.Expression != nil &&
+      p.Expression.Kind == shimast.KindConditionalExpression {
+      inner = p.Expression
+    }
+  }
+  if inner != nil && inner.Kind == shimast.KindConditionalExpression {
+    // A nested chain's arms align at 2 past their parent rung. Prettier's
+    // ternary-old.js uses that as-is for an ALTERNATE-position nested chain
+    // (`align(2)`), but a CONSEQUENT-position one gets an extra
+    // `align(Math.max(0, tabWidth - 2))`, for a total of `max(2, tabWidth)`.
+    // The two coincide at the default tabWidth 2; they diverge at tabWidth > 2.
+    indentCols := 2
+    if isConsequent {
+      if u := ctx.indentUnit(); u > indentCols {
+        indentCols = u
+      }
+    }
+    chain, covered := buildConditionalChain(ctx, inner, indentCols)
     if isConsequent {
       // `ifBreak("", "(")` … `ifBreak("", ")")`: parens in flat mode only.
       chain = Concat(

package/linthost/rules_format_arrow_parens.go

@@ -77,6 +77,17 @@ func (formatArrowParens) Check(ctx *Context, node *shimast.Node) {
     return
   }
 
+  // A comment in the parameter region (leading trivia, or between the name and
+  // its `)`/`=>`) defeats the whitespace-only paren scan below: the scan stops
+  // at the comment byte and reports "not wrapped", so the "always" branch would
+  // wrap an already-parenthesized name a second time and emit invalid
+  // `(/* c */ (x)) => x`. Prettier leaves such an arrow alone
+  // (canPrintParamsWithoutParens requires `!hasComment(parameters[0])`), so
+  // abstain rather than corrupt.
+  if arrowParamRegionHasComment(src, param.Pos(), nameStart, nameEnd) {
+    return
+  }
+
   // Is the parameter already wrapped in `(` … `)`? Scan over whitespace on
   // each side; the sole parameter of an arrow is delimited by the
   // parameter-list parens when present.
@@ -162,6 +173,41 @@ func scanForwardForByte(src string, from int, target byte) int {
   return -1
 }
 
+// arrowParamRegionHasComment reports whether a `//` or `/*` comment sits in the
+// single parameter's region — its leading trivia (`[paramPos, nameStart)`) or
+// the trailing trivia after the name up to the first real token (`)` or `=>`).
+// The byte scan is safe here because a bare-identifier parameter region holds
+// only comments, whitespace, the identifier, and parentheses (no strings:
+// typed/defaulted params are already excluded by isBareIdentifierParam).
+func arrowParamRegionHasComment(src string, paramPos, nameStart, nameEnd int) bool {
+  for i := paramPos; i+1 < nameStart && i+1 < len(src); i++ {
+    if src[i] == '/' && (src[i+1] == '*' || src[i+1] == '/') {
+      return true
+    }
+  }
+  // Trailing trivia after the identifier, up to `=>`. Tolerate one closing
+  // paren so a comment between `)` and `=>` (`(x) /* c */ => x`) — which in
+  // "avoid" mode would otherwise be stranded when the parens are stripped — is
+  // also detected (Prettier keeps the parens of an arrow with such a dangling
+  // comment).
+  sawParen := false
+  for i := nameEnd; i+1 < len(src); i++ {
+    c := src[i]
+    if c == ' ' || c == '\t' || c == '\r' || c == '\n' {
+      continue
+    }
+    if c == '/' && (src[i+1] == '*' || src[i+1] == '/') {
+      return true
+    }
+    if c == ')' && !sawParen {
+      sawParen = true
+      continue
+    }
+    break
+  }
+  return false
+}
+
 func init() {
   Register(formatArrowParens{})
 }

package/linthost/rules_format_clause_join.go

@@ -96,6 +96,14 @@ func joinClauseBody(
   if body == nil || body.Kind == shimast.KindBlock {
     return
   }
+  // An empty-statement body (`while (x)\n;`) glues directly to the header with
+  // NO space: Prettier's adjustClause special-cases EmptyStatement and returns
+  // the bare `;` (`while (x);`), only prepending a space when the empty
+  // statement carries a leading comment. This rule's gap->" " rewrite cannot
+  // produce the spaceless `);` glue, so abstain and leave the source shape.
+  if body.Kind == shimast.KindEmptyStatement {
+    return
+  }
   bodyStart := shimscanner.SkipTrivia(src, body.Pos())
   bodyEnd := body.End()
   if bodyStart < 0 || bodyEnd < bodyStart || bodyEnd > len(src) {
@@ -149,12 +157,11 @@ func isClauseGapByte(c byte) bool {
   return c == ' ' || c == '\t' || c == '\r' || c == '\n'
 }
 
-// visualWidth returns the column width of `s`, expanding tab characters
-// to `tabWidth` columns. Non-tab bytes count as one column, which is
-// exact for the ASCII that dominates control-flow headers and the common
-// case; it can under/over-count multi-byte runes, but clause bodies that
-// land exactly on the printWidth boundary are rare enough that the
-// approximation never changes a real join decision.
+// visualWidth returns the display-column width of `s`: a tab expands to a flat
+// `tabWidth` columns and every other rune is charged its display width via
+// runeWidth (combining marks 0, wide East-Asian/emoji 2), matching displayWidth.
+// The only approximation left is the flat tab expansion (no tab-stop rounding),
+// which never changes a real clause-join decision.
 func visualWidth(s string, tabWidth int) int {
   width := 0
   for _, r := range s {

package/linthost/rules_format_print_width.go

@@ -93,11 +93,6 @@ func (formatPrintWidth) Visits() []shimast.Kind {
 //     re-render still over-breaks some of these; the next slice should
 //     measure fitsFirstLine against `pw - col - trailingNonComment`
 //     before committing to the broken layout.
-//   - Default-combined imports (`import D, { X } from "x"`) are kept
-//     verbatim by printImportDeclaration (its `clause.Name() != nil`
-//     guard), so a default import whose named clause overflows is not
-//     broken; Prettier breaks it. Lifting the guard, threading the default
-//     name into the printed prefix, is a future default-import reflow slice.
 //
 // (A single-specifier `import/export { X } from "long-path"` that overflows
 // only because of the `from "..."` tail is now kept inline by the
@@ -162,15 +157,15 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
   // the per-byte comment scan in hasNonChildComments. Charging that
   // cost only on nodes that actually overflow keeps the hot path on
   // well-formatted code allocation- and scan-free.
-  // A call with two or more function/arrow arguments explodes regardless of
-  // width (Prettier's multiple-callback rule), and an array of same-kind
-  // multi-child arrays/objects explodes under Prettier's shouldBreak heuristic,
-  // so a flat one-line node of either shape still needs a reflow. Skip the fast
-  // path for them; the printer's ForceBreak then produces the exploded shape.
-  // Everything else that fits flat is byte-identical after reflow, so the fast
-  // path stands.
-  if !callForcesFunctionBreak(node) &&
-    !arrayForcesBreak(node) &&
+  // A call/new with two or more callback arguments explodes regardless of width
+  // (Prettier's multiple-callback rule), and an array of same-kind multi-child
+  // arrays/objects explodes under Prettier's shouldBreak heuristic — even when
+  // such a node is nested inside an otherwise-fitting call/new/array. So a flat
+  // one-line node containing either shape still needs a reflow. fastPathForcesBreak
+  // walks the reflow subtree; skip the fast path for it so the printer's
+  // ForceBreak produces the exploded shape. Everything else that fits flat is
+  // byte-identical after reflow, so the fast path stands.
+  if !fastPathForcesBreak(node) &&
     !sliceContainsNewline(src, start, end) &&
     printOpts.StartingColumn+displayWidth(src[start:end])+trailingWidth <= printOpts.PrintWidth {
     return

package/linthost/rules_format_sort_imports.go

@@ -359,6 +359,12 @@ type siSpec struct {
   sortKey          string
   text             string
   fromTypeOnlyDecl bool
+  // inlineType is the specifier's own AST `type` modifier (`import { type Foo }`),
+  // distinct from fromTypeOnlyDecl (the whole `import type { … }` declaration).
+  // It classifies a specifier without re-parsing its text, so a binding literally
+  // named `type` (`import { type as bar }` -> name `type`, alias `bar`, NOT a type
+  // specifier) is not mistaken for a type modifier by a `"type "` string prefix.
+  inlineType bool
 }
 
 // siDecl is the parsed shape of one import declaration used by the block
@@ -371,8 +377,13 @@ type siDecl struct {
   defaultName string
   named       []siSpec
   namespace   bool
-  original    string
-  semicolon   bool
+  // hasSpecComment marks a declaration whose named-import braces carry a comment.
+  // The merge rebuilder joins specifier texts with ", " and would drop such a
+  // comment, so a flagged declaration is made unmergeable (like a namespace
+  // binding) and re-emitted from its original text. See mergeKey.
+  hasSpecComment bool
+  original       string
+  semicolon      bool
 }
 
 // siEntry is a (possibly merged) import declaration ready to be grouped,
@@ -451,6 +462,42 @@ func parseImportDecl(src string, decl *shimast.Node) siDecl {
   }
   out.typeOnly = clause.PhaseModifier == shimast.KindTypeKeyword
   out.defaultName = identifierText(clause.Name())
+  // A comment anywhere in the rebuilt import prefix (`import [type] [D] [, { … }]
+  // from `) would be lost when renderMergedDecl reconstructs the statement
+  // field-by-field. Flag it so mergeKey keeps the declaration unmergeable and
+  // its original text is preserved. This runs BEFORE the no-named-bindings /
+  // namespace early returns so a default-only import (`import a /* c */ from
+  // "m"`) is flagged too; it depends only on decl.Pos() and the module
+  // specifier, not on the named bindings. The prefix holds no module-path
+  // string, so a `//` or `/*` there is unambiguously a comment (a leading
+  // comment before `import` is excluded: SkipTrivia advances to `import`).
+  if imp.ModuleSpecifier != nil {
+    pStart := shimscanner.SkipTrivia(src, decl.Pos())
+    pEnd := shimscanner.SkipTrivia(src, imp.ModuleSpecifier.Pos())
+    if pStart >= 0 && pEnd <= len(src) && pStart < pEnd {
+      if span := src[pStart:pEnd]; strings.Contains(span, "//") || strings.Contains(span, "/*") {
+        out.hasSpecComment = true
+      }
+    }
+    // Also the module-specifier -> `;` tail (`from "m" /* keep */;`): a block
+    // comment there is interior to the declaration but outside the
+    // inter-declaration gap that leadingTriviaIsAllWhitespace scans, so the
+    // merge rebuilder would drop it. The module string itself is excluded (the
+    // span starts at ModuleSpecifier.End()), so no `//`-in-a-path false positive.
+    if tStart, tEnd := imp.ModuleSpecifier.End(), decl.End(); tStart >= 0 && tEnd <= len(src) && tStart < tEnd {
+      if span := src[tStart:tEnd]; strings.Contains(span, "//") || strings.Contains(span, "/*") {
+        out.hasSpecComment = true
+      }
+    }
+  }
+  // An import-attributes clause (`with { type: "json" }` / `assert { … }`) is not
+  // reconstructed by renderMergedDecl, so merging would silently drop those
+  // bytes. Flag the declaration unmergeable (its original text is then re-emitted
+  // verbatim), mirroring the print-width import printer, which bails to verbatim
+  // on `imp.Attributes != nil` for the same reason.
+  if imp.Attributes != nil {
+    out.hasSpecComment = true
+  }
   if clause.NamedBindings == nil {
     return out
   }
@@ -475,6 +522,7 @@ func parseImportDecl(src string, decl *shimast.Node) siDecl {
       sortKey:          identifierText(s.Name()),
       text:             src[start:spec.End()],
       fromTypeOnlyDecl: out.typeOnly,
+      inlineType:       s.IsTypeOnly,
     })
   }
   return out
@@ -509,6 +557,11 @@ func mergeKey(d siDecl, combine bool) string {
   if d.namespace {
     return "\x00ns\x00" + d.original
   }
+  // A named-import list carrying a comment is unmergeable so the comment
+  // survives in the declaration's original text (a per-declaration key).
+  if d.hasSpecComment {
+    return "\x00cmt\x00" + d.original
+  }
   if combine || !d.typeOnly {
     return "v\x00" + d.specifier
   }
@@ -613,10 +666,18 @@ func collectMergedSpecs(group []siDecl, mergedTypeOnly, caseSensitive bool) []st
   for _, d := range group {
     for _, s := range d.named {
       text := s.text
-      if s.fromTypeOnlyDecl && !mergedTypeOnly && !strings.HasPrefix(text, "type ") {
+      // Classify by AST flags, not a `"type "` text prefix. A binding literally
+      // named `type` (`import { type as bar }`) has inlineType=false and must stay
+      // a value specifier; a string-prefix check would mis-promote it to a type
+      // specifier and skip the modifier when folding a type-only declaration.
+      isType := s.inlineType
+      if s.fromTypeOnlyDecl && !mergedTypeOnly {
+        // A specifier from `import type { … }` carries no inline `type` modifier
+        // (TS forbids it there), so folding into a mixed value import must add one.
         text = "type " + text
+        isType = true
       }
-      cur := spec{name: s.sortKey, isType: strings.HasPrefix(text, "type "), text: text}
+      cur := spec{name: s.sortKey, isType: isType, text: text}
       if at, dup := index[s.sortKey]; dup {
         if items[at].isType && !cur.isType {
           items[at] = cur

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -36,7 +36,7 @@
     "@typescript/native-preview": "7.0.0-dev.20260519.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.14.0"
+    "ttsc": "0.14.1"
   },
   "repository": {
     "type": "git",