@ttsc/lint 0.18.4 → 0.19.1

package/linthost/lsp.go

@@ -1,6 +1,8 @@
 package linthost
 
 import (
+  "context"
+  "crypto/sha256"
   "encoding/json"
   "errors"
   "flag"
@@ -17,11 +19,14 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 const (
-  commandLintFixAll     = "ttsc.lint.fixAll"
-  commandFormatDocument = "ttsc.format.document"
+  commandLintFixAll          = "ttsc.lint.fixAll"
+  commandLintApplySuggestion = "ttsc.lint.applySuggestion"
+  commandFormatDocument      = "ttsc.format.document"
 )
 
 type lspPosition struct {
@@ -34,6 +39,16 @@ type lspRange struct {
   End   lspPosition `json:"end"`
 }
 
+type lspPositionWire struct {
+  Line      *int `json:"line"`
+  Character *int `json:"character"`
+}
+
+type lspRangeWire struct {
+  Start *lspPositionWire `json:"start"`
+  End   *lspPositionWire `json:"end"`
+}
+
 type lspDiagnostic struct {
   Range    lspRange `json:"range"`
   Severity int      `json:"severity,omitempty"`
@@ -68,6 +83,27 @@ type lspWorkspaceEdit struct {
   Changes map[string][]lspTextEdit `json:"changes,omitempty"`
 }
 
+type lspSuggestionSelection struct {
+  Rule            string `json:"rule"`
+  Message         string `json:"message"`
+  Pos             int    `json:"pos"`
+  End             int    `json:"end"`
+  SuggestionIndex int    `json:"suggestionIndex"`
+  Title           string `json:"title"`
+  SourceHash      string `json:"sourceHash"`
+  Fingerprint     string `json:"fingerprint"`
+}
+
+type lspProjectDiagnostics struct {
+  URI         string          `json:"uri"`
+  Diagnostics []lspDiagnostic `json:"diagnostics"`
+}
+
+type lspDiagnosticsResult struct {
+  Document []lspDiagnostic        `json:"document"`
+  Project  *lspProjectDiagnostics `json:"project,omitempty"`
+}
+
 type lspCommandOptions struct {
   argumentsJSON string
   command       string
@@ -79,24 +115,26 @@ type lspCommandOptions struct {
   contentStdin bool
   cwd          string
   pluginsJSON  string
-  // rangeJSON is accepted from the ttsc LSP server
-  // (`internal/lspserver/lsp_native_plugin_source.go`) for forward
-  // compatibility, but no current code path consumes it — code actions
-  // always operate on the full file. Range-aware actions can read this
-  // field once they're implemented.
-  rangeJSON string
-  tsconfig  string
-  uri       string
+  // rangeJSON carries the editor selection used to limit quickfix.ttsc
+  // actions. Source fix-all and format actions remain document-wide.
+  rangeJSON       string
+  tsconfig        string
+  uri             string
+  projectIdentity publicrule.ProjectIdentity
 }
 
 // RunLSPCommandIDs prints the workspace/executeCommand ids owned by @ttsc/lint.
 func RunLSPCommandIDs([]string) int {
-  return writeJSON([]string{commandLintFixAll, commandFormatDocument})
+  return writeJSON([]string{
+    commandLintFixAll,
+    commandLintApplySuggestion,
+    commandFormatDocument,
+  })
 }
 
 // RunLSPCodeActionKinds prints the CodeActionKind values @ttsc/lint may return.
 func RunLSPCodeActionKinds([]string) int {
-  return writeJSON([]string{"source.fixAll.ttsc", "source.format"})
+  return writeJSON([]string{"quickfix.ttsc", "source.fixAll.ttsc", "source.format"})
 }
 
 // RunLSPDiagnostics prints lint diagnostics for one file URI as LSP JSON.
@@ -105,18 +143,28 @@ func RunLSPDiagnostics(args []string) int {
   if !ok {
     return 2
   }
-  findings, _, closeProgram, code := lspFindings(opts, false)
+  findings, prog, closeProgram, code := lspFindings(opts, false)
   if closeProgram != nil {
     defer closeProgram()
   }
   if code != 0 {
     return code
   }
-  diagnostics := make([]lspDiagnostic, 0, len(findings))
-  for _, finding := range findings {
-    diagnostics = append(diagnostics, findingToLSPDiagnostic(finding))
+  result := lspDiagnosticsResult{Document: []lspDiagnostic{}}
+  for _, finding := range filterFindingsForPath(findings, mustFilePathFromURI(opts.uri)) {
+    result.Document = append(result.Document, findingToLSPDiagnostic(finding))
   }
-  return writeJSON(diagnostics)
+  if prog != nil && prog.projectCycle != nil && len(prog.projectCycle.results.byName) > 0 {
+    publication := &lspProjectDiagnostics{
+      URI:         fileURL(prog.identity.LogicalConfigPath),
+      Diagnostics: []lspDiagnostic{},
+    }
+    for _, finding := range prog.projectCycle.findings {
+      publication.Diagnostics = append(publication.Diagnostics, findingToLSPDiagnostic(finding))
+    }
+    result.Project = publication
+  }
+  return writeJSON(result)
 }
 
 // RunLSPCodeActions prints code actions available for one file URI/range.
@@ -126,8 +174,13 @@ func RunLSPCodeActions(args []string) int {
     return 2
   }
   acceptsLint := acceptsActionKind(opts.contextJSON, "source.fixAll.ttsc")
+  acceptsQuickFix := acceptsActionKind(opts.contextJSON, "quickfix.ttsc")
   acceptsFormat := acceptsActionKind(opts.contextJSON, "source.format")
-  if !acceptsLint && !acceptsFormat {
+  quickFixRange, quickFixRangeOK := parseRequestedLSPRange(opts.rangeJSON)
+  if acceptsQuickFix && !quickFixRangeOK {
+    acceptsQuickFix = false
+  }
+  if !acceptsLint && !acceptsQuickFix && !acceptsFormat {
     return writeJSON([]lspCodeAction{})
   }
   if lspProjectTargetHasSegment(opts, "node_modules") {
@@ -143,9 +196,13 @@ func RunLSPCodeActions(args []string) int {
   if code != 0 {
     return code
   }
+  findings = filterFindingsForPath(findings, mustFilePathFromURI(opts.uri))
   lintFindings := filterLintFindings(findings)
   formatFindings := filterFormatFindings(findings)
   var actions []lspCodeAction
+  if acceptsQuickFix {
+    actions = append(actions, lspSuggestionCodeActions(opts, lintFindings, quickFixRange)...)
+  }
   if acceptsLint && hasFixableFinding(lintFindings) {
     uriArg, _ := json.Marshal(opts.uri)
     actions = append(actions, lspCodeAction{
@@ -180,7 +237,9 @@ func RunLSPExecuteCommand(args []string) int {
   if !ok {
     return 2
   }
-  if opts.command != commandLintFixAll && opts.command != commandFormatDocument {
+  if opts.command != commandLintFixAll &&
+    opts.command != commandLintApplySuggestion &&
+    opts.command != commandFormatDocument {
     fmt.Fprintf(os.Stderr, "@ttsc/lint lsp-execute-command: unknown command %q\n", opts.command)
     return 2
   }
@@ -190,6 +249,13 @@ func RunLSPExecuteCommand(args []string) int {
     return 2
   }
   opts.uri = uri
+  if opts.command == commandLintApplySuggestion {
+    edit, code := lspWorkspaceEditForSuggestion(opts)
+    if code != 0 {
+      return code
+    }
+    return writeJSON(edit)
+  }
   // --content-stdin selects the lightweight in-memory format path: the full
   // document buffer is read from stdin and formatted with AST+source rules
   // only, with no temp-workspace copy and no tsgo Program. It applies to
@@ -221,6 +287,7 @@ func parseLSPCommandOptions(name string, args []string) (*lspCommandOptions, boo
   cwd := fs.String("cwd", "", "")
   tsconfig := fs.String("tsconfig", "tsconfig.json", "")
   pluginsJSON := fs.String("plugins-json", "", "")
+  projectContextJSON := fs.String("project-context-json", "", "")
   uri := fs.String("uri", "", "")
   rangeJSON := fs.String("range-json", "", "")
   contextJSON := fs.String("context-json", "", "")
@@ -235,16 +302,22 @@ func parseLSPCommandOptions(name string, args []string) (*lspCommandOptions, boo
     fmt.Fprintln(os.Stderr, err)
     return nil, false
   }
+  projectIdentity, err := decodeProjectIdentity(*projectContextJSON)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, false
+  }
   return &lspCommandOptions{
-    argumentsJSON: *argumentsJSON,
-    command:       *command,
-    contextJSON:   *contextJSON,
-    contentStdin:  *contentStdin,
-    cwd:           resolvedCwd,
-    pluginsJSON:   *pluginsJSON,
-    rangeJSON:     *rangeJSON,
-    tsconfig:      *tsconfig,
-    uri:           *uri,
+    argumentsJSON:   *argumentsJSON,
+    command:         *command,
+    contextJSON:     *contextJSON,
+    contentStdin:    *contentStdin,
+    cwd:             resolvedCwd,
+    pluginsJSON:     *pluginsJSON,
+    rangeJSON:       *rangeJSON,
+    tsconfig:        *tsconfig,
+    uri:             *uri,
+    projectIdentity: projectIdentity,
   }, true
 }
 
@@ -258,18 +331,26 @@ func lspFindings(opts *lspCommandOptions, includeFormatDefaults bool) ([]*Findin
     fmt.Fprintln(os.Stderr, err)
     return nil, nil, nil, 2
   }
-  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  rules, err := loadLSPCommandRules(
+    opts.pluginsJSON,
+    opts.cwd,
+    opts.tsconfig,
+    target,
+    includeFormatDefaults,
+  )
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, nil, nil, 2
   }
-  if includeFormatDefaults {
-    rules = formatCommandResolver{inner: rules}
-  }
   engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, nil, nil, 2
+  }
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
     forceNoEmit:      true,
     needsRuleChecker: engine.NeedsTypeChecker(),
+    projectIdentity:  opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -279,18 +360,53 @@ func lspFindings(opts *lspCommandOptions, includeFormatDefaults bool) ([]*Findin
     // tsgo already owns parse diagnostics in the upstream LSP process.
     return nil, prog, prog.close, 0
   }
-  findings := filterFindingsForPath(engine.Run(prog.userSourceFiles(), prog.checker), target)
+  findings := prog.runLintCycle(engine)
   return findings, prog, prog.close, 0
 }
 
+// loadLSPCommandRules constructs the resolver shared by every LSP command
+// path. Format requests use the same missing-config fallback, documented
+// defaults, editor overrides, and language precedence as the CLI formatter and
+// in-memory buffer formatter; lint-only requests retain the strict lint loader.
+// formatTarget is the real editor document even when cwd/tsconfig point at the
+// temporary workspace used by the disk execute-command path.
+func loadLSPCommandRules(
+  pluginsJSON string,
+  cwd string,
+  tsconfigPath string,
+  formatTarget string,
+  includeFormatDefaults bool,
+) (RuleResolver, error) {
+  if !includeFormatDefaults {
+    return loadRules(pluginsJSON, cwd, tsconfigPath)
+  }
+  rules, err := loadFormatRules(pluginsJSON, cwd, tsconfigPath)
+  if err != nil {
+    return nil, err
+  }
+  return newFormatCommandResolver(
+    rules,
+    filepath.Dir(formatTarget),
+    vscodeLanguageID(formatTarget),
+  )
+}
+
+func mustFilePathFromURI(uri string) string {
+  target, err := filePathFromURI(uri)
+  if err != nil {
+    return ""
+  }
+  return target
+}
+
 func filterFindingsForPath(findings []*Finding, target string) []*Finding {
-  target = canonicalProjectPath("", target)
+  target = canonicalProjectPath("", realProjectPath(target))
   out := make([]*Finding, 0, len(findings))
   for _, finding := range findings {
     if finding == nil || finding.File == nil {
       continue
     }
-    if canonicalProjectPath("", finding.File.FileName()) == target {
+    if canonicalProjectPath("", realProjectPath(finding.File.FileName())) == target {
       out = append(out, finding)
     }
   }
@@ -366,24 +482,267 @@ func acceptsActionKind(raw string, kind string) bool {
   return false
 }
 
-func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int) {
+func lspSuggestionCodeActions(
+  opts *lspCommandOptions,
+  findings []*Finding,
+  requestedRange lspRange,
+) []lspCodeAction {
+  actions := make([]lspCodeAction, 0)
+  sourceHashes := make(map[*shimast.SourceFile]string)
+  for _, finding := range findings {
+    if finding == nil || finding.File == nil || len(finding.Suggestions) == 0 {
+      continue
+    }
+    if !lspRangesOverlap(requestedRange, lspRangeForFinding(finding)) {
+      continue
+    }
+    sourceHash, ok := sourceHashes[finding.File]
+    if !ok {
+      sourceHash = lspSourceHash(finding.File.Text())
+      sourceHashes[finding.File] = sourceHash
+    }
+    for index, suggestion := range finding.Suggestions {
+      if suggestion.Title == "" || len(suggestion.Edits) == 0 {
+        continue
+      }
+      uriArg, err := json.Marshal(opts.uri)
+      if err != nil {
+        continue
+      }
+      selectionArg, err := json.Marshal(lspSuggestionSelection{
+        Rule:            finding.Rule,
+        Message:         finding.Message,
+        Pos:             finding.Pos,
+        End:             finding.End,
+        SuggestionIndex: index,
+        Title:           suggestion.Title,
+        SourceHash:      sourceHash,
+        Fingerprint:     lspSuggestionFingerprint(finding, suggestion),
+      })
+      if err != nil {
+        continue
+      }
+      actions = append(actions, lspCodeAction{
+        Title: suggestion.Title,
+        Kind:  "quickfix.ttsc",
+        Command: &lspCommand{
+          Title:     suggestion.Title,
+          Command:   commandLintApplySuggestion,
+          Arguments: []json.RawMessage{uriArg, selectionArg},
+        },
+      })
+    }
+  }
+  return actions
+}
+
+func parseRequestedLSPRange(raw string) (lspRange, bool) {
+  var wire lspRangeWire
+  if strings.TrimSpace(raw) == "" || json.Unmarshal([]byte(raw), &wire) != nil ||
+    wire.Start == nil || wire.End == nil ||
+    wire.Start.Line == nil || wire.Start.Character == nil ||
+    wire.End.Line == nil || wire.End.Character == nil {
+    return lspRange{}, false
+  }
+  requested := lspRange{
+    Start: lspPosition{Line: *wire.Start.Line, Character: *wire.Start.Character},
+    End:   lspPosition{Line: *wire.End.Line, Character: *wire.End.Character},
+  }
+  if requested.Start.Line < 0 || requested.Start.Character < 0 ||
+    requested.End.Line < 0 || requested.End.Character < 0 ||
+    compareLSPPositions(requested.Start, requested.End) > 0 {
+    return lspRange{}, false
+  }
+  return requested, true
+}
+
+func lspRangesOverlap(left lspRange, right lspRange) bool {
+  if compareLSPPositions(left.Start, left.End) == 0 {
+    return compareLSPPositions(left.Start, right.Start) >= 0 &&
+      compareLSPPositions(left.Start, right.End) < 0
+  }
+  if compareLSPPositions(right.Start, right.End) == 0 {
+    return compareLSPPositions(right.Start, left.Start) >= 0 &&
+      compareLSPPositions(right.Start, left.End) < 0
+  }
+  return compareLSPPositions(left.Start, right.End) < 0 &&
+    compareLSPPositions(right.Start, left.End) < 0
+}
+
+func compareLSPPositions(left lspPosition, right lspPosition) int {
+  if left.Line < right.Line {
+    return -1
+  }
+  if left.Line > right.Line {
+    return 1
+  }
+  if left.Character < right.Character {
+    return -1
+  }
+  if left.Character > right.Character {
+    return 1
+  }
+  return 0
+}
+
+func lspSourceHash(source string) string {
+  return fmt.Sprintf("%x", sha256.Sum256([]byte(source)))
+}
+
+func lspSuggestionFingerprint(finding *Finding, suggestion Suggestion) string {
+  payload, _ := json.Marshal(struct {
+    Rule    string     `json:"rule"`
+    Message string     `json:"message"`
+    Pos     int        `json:"pos"`
+    End     int        `json:"end"`
+    Title   string     `json:"title"`
+    Edits   []TextEdit `json:"edits"`
+  }{
+    Rule:    finding.Rule,
+    Message: finding.Message,
+    Pos:     finding.Pos,
+    End:     finding.End,
+    Title:   suggestion.Title,
+    Edits:   suggestion.Edits,
+  })
+  return fmt.Sprintf("%x", sha256.Sum256(payload))
+}
+
+func lspWorkspaceEditForSuggestion(opts *lspCommandOptions) (*lspWorkspaceEdit, int) {
   target, err := filePathFromURI(opts.uri)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, 2
   }
-  if _, ok := projectRelativePath(opts.cwd, target); !ok {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP command target %s is outside cwd %s\n", target, opts.cwd)
+  physicalCwd := realProjectPath(opts.cwd)
+  physicalTarget := realProjectPath(target)
+  if _, ok := projectRelativePath(physicalCwd, physicalTarget); !ok {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP command target %s is outside cwd %s\n", physicalTarget, physicalCwd)
+    return nil, 2
+  }
+  if lspProjectTargetHasSegment(opts, "node_modules") {
+    return nil, 0
+  }
+  selection, err := suggestionSelectionArgument(opts.argumentsJSON)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
     return nil, 2
   }
-  if projectPathHasSegment(opts.cwd, target, "node_modules") {
+  current, err := os.ReadFile(physicalTarget)
+  if err != nil || lspSourceHash(string(current)) != selection.SourceHash {
     return nil, 0
   }
+  findings, _, closeProgram, code := lspFindings(opts, false)
+  if closeProgram != nil {
+    defer closeProgram()
+  }
+  if code != 0 {
+    return nil, code
+  }
+  findings = filterFindingsForPath(findings, physicalTarget)
+  for _, finding := range findings {
+    if finding == nil || finding.Rule != selection.Rule ||
+      finding.Message != selection.Message ||
+      finding.Pos != selection.Pos || finding.End != selection.End ||
+      selection.SuggestionIndex >= len(finding.Suggestions) {
+      continue
+    }
+    suggestion := finding.Suggestions[selection.SuggestionIndex]
+    if suggestion.Title != selection.Title || finding.File == nil ||
+      lspSourceHash(finding.File.Text()) != selection.SourceHash ||
+      lspSuggestionFingerprint(finding, suggestion) != selection.Fingerprint {
+      continue
+    }
+    source := finding.File.Text()
+    selected := selectTextEdits(len(source), suggestion.Edits)
+    if len(selected) == 0 || len(selected) != len(suggestion.Edits) {
+      return nil, 0
+    }
+    edits := make([]lspTextEdit, 0, len(selected))
+    for _, edit := range selected {
+      edits = append(edits, lspTextEdit{
+        Range: lspRange{
+          Start: byteOffsetToLSPPosition(source, edit.Pos),
+          End:   byteOffsetToLSPPosition(source, edit.End),
+        },
+        NewText: edit.Text,
+      })
+    }
+    current, err := os.ReadFile(physicalTarget)
+    if err != nil || lspSourceHash(string(current)) != selection.SourceHash {
+      return nil, 0
+    }
+    return &lspWorkspaceEdit{Changes: map[string][]lspTextEdit{opts.uri: edits}}, 0
+  }
+  return nil, 0
+}
+
+func suggestionSelectionArgument(raw string) (lspSuggestionSelection, error) {
+  var args []json.RawMessage
+  if strings.TrimSpace(raw) == "" || json.Unmarshal([]byte(raw), &args) != nil || len(args) < 2 {
+    return lspSuggestionSelection{}, errors.New("@ttsc/lint lsp-execute-command: missing suggestion selection argument")
+  }
+  var selection lspSuggestionSelection
+  if err := json.Unmarshal(args[1], &selection); err != nil {
+    return lspSuggestionSelection{}, fmt.Errorf("@ttsc/lint lsp-execute-command: invalid suggestion selection: %w", err)
+  }
+  if selection.Rule == "" || selection.Message == "" || selection.Title == "" ||
+    len(selection.SourceHash) != sha256.Size*2 ||
+    len(selection.Fingerprint) != sha256.Size*2 ||
+    selection.Pos < 0 || selection.End < selection.Pos || selection.SuggestionIndex < 0 {
+    return lspSuggestionSelection{}, errors.New("@ttsc/lint lsp-execute-command: invalid suggestion selection")
+  }
+  return selection, nil
+}
+
+func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int) {
+  target, err := filePathFromURI(opts.uri)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
+  if lspProjectTargetHasSegment(opts, "node_modules") {
+    return nil, 0
+  }
+  // Containment is the only physical guard: resolve both sides so a symlinked
+  // or short-name spelling of either cannot smuggle the target outside cwd.
+  // `target` itself stays in its LOGICAL (URI) spelling for everything that
+  // indexes into the temp workspace below — the temp tree materializes a
+  // project-internal symlink/junction under its logical name, so resolving the
+  // target to its physical destination here would address a path the temp tree
+  // never created (samchon/ttsc#614).
+  physicalCwd := realProjectPath(opts.cwd)
+  physicalTarget := realProjectPath(target)
+  if _, ok := projectRelativePath(physicalCwd, physicalTarget); !ok {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP command target %s is outside cwd %s\n", physicalTarget, physicalCwd)
+    return nil, 2
+  }
   original, err := os.ReadFile(target)
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: read %s: %v\n", target, err)
     return nil, 2
   }
+  return lspWorkspaceEditForSeededCommand(opts, target, string(original), nil)
+}
+
+// lspWorkspaceEditForSeededCommand runs a command in the ordinary temporary
+// project while optionally replacing the target copy with editor-owned text.
+// original is always the document against which the returned full-document
+// edit is measured. A non-nil sourceOverlay is written only inside the
+// temporary workspace, so type-aware contributor rules receive a real Program
+// and Checker for the dirty document without using or mutating its disk twin as
+// command input. Dirty buffers with syntax errors fail closed before any fix is
+// applied.
+func lspWorkspaceEditForSeededCommand(
+  opts *lspCommandOptions,
+  target string,
+  original string,
+  sourceOverlay *string,
+) (*lspWorkspaceEdit, int) {
+  // Pass the LOGICAL cwd/target so the temp workspace is indexed by the
+  // project's logical layout (a project-internal symlink or junction keeps its
+  // logical name). Physical resolution stays inside prepareLSPCommandWorkspace
+  // for the copy source and inside tempPathFor's boundary-alias fallback.
   tempRoot, tempTarget, tempTsconfig, cleanup, err := prepareLSPCommandWorkspace(opts.cwd, opts.tsconfig, target)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
@@ -391,16 +750,34 @@ func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int
   }
   defer cleanup()
 
+  if sourceOverlay != nil {
+    if err := os.MkdirAll(filepath.Dir(tempTarget), 0o755); err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: create dirty-buffer directory: %v\n", err)
+      return nil, 2
+    }
+    if err := os.WriteFile(tempTarget, []byte(*sourceOverlay), 0o600); err != nil {
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: seed dirty buffer %s: %v\n", target, err)
+      return nil, 2
+    }
+  }
+
   pluginsJSON := remapLSPPluginsJSONForTempWorkspace(opts.pluginsJSON, opts.cwd, tempRoot)
-  rules, err := loadRules(pluginsJSON, tempRoot, tempTsconfig)
+  rules, err := loadLSPCommandRules(
+    pluginsJSON,
+    tempRoot,
+    tempTsconfig,
+    target,
+    opts.command == commandFormatDocument,
+  )
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, 2
   }
-  if opts.command == commandFormatDocument {
-    rules = formatCommandResolver{inner: rules}
-  }
   engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return nil, 2
+  }
   needsRuleChecker := engine.NeedsTypeChecker()
   maxPasses := maxFixPasses
   if opts.command == commandFormatDocument {
@@ -411,6 +788,7 @@ func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int
     prog, parseDiags, err := loadProgram(tempRoot, tempTsconfig, loadProgramOptions{
       forceNoEmit:      true,
       needsRuleChecker: needsRuleChecker,
+      projectIdentity:  opts.projectIdentity,
     })
     if err != nil {
       fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -420,7 +798,27 @@ func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int
       prog.close()
       return nil, 0
     }
-    findings := filterFindingsForPath(engine.Run(prog.userSourceFiles(), prog.checker), tempTarget)
+    // The command target must resolve to a source file the temp program loaded.
+    // A nil here means the temp workspace did not materialize the target under
+    // the spelling the tsconfig references — the signature of the symlink/
+    // junction copy regression. Fail loud (exit 2) instead of returning a silent
+    // nil edit the editor cannot distinguish from an already-clean document.
+    targetFile := prog.findSourceFile(tempTarget)
+    if targetFile == nil {
+      prog.close()
+      fmt.Fprintf(os.Stderr,
+        "@ttsc/lint: LSP %s: target source file %s is not in the program\n",
+        opts.command, tempTarget)
+      return nil, 2
+    }
+    if sourceOverlay != nil &&
+      len(prog.tsProgram.GetSyntacticDiagnostics(context.Background(), targetFile)) > 0 {
+      // A dirty overlay buffer with syntax errors is a benign no-op: don't fight
+      // the editor's own diagnostics on the dirty document with a partial fix.
+      prog.close()
+      return nil, 0
+    }
+    findings := filterFindingsForPath(prog.runLintCycle(engine), tempTarget)
     prog.close()
     if opts.command == commandFormatDocument {
       findings = filterFormatFindings(findings)
@@ -448,18 +846,18 @@ func lspWorkspaceEditForCommand(opts *lspCommandOptions) (*lspWorkspaceEdit, int
     fmt.Fprintf(os.Stderr, "@ttsc/lint: read cascaded %s: %v\n", tempTarget, err)
     return nil, 2
   }
-  return workspaceEditForFullDocument(opts.uri, string(original), string(next)), 0
+  return workspaceEditForFullDocument(opts.uri, original, string(next)), 0
 }
 
 // lspFormatBuffer formats an in-memory document buffer using only the
-// format-class rules, with no tsgo Program and no temp-workspace copy. It is
-// the lightweight path behind --content-stdin for ttsc.format.document.
+// format-class rules. It is the path behind --content-stdin for
+// ttsc.format.document.
 //
-// Format rules are AST+source only (`IsFormat() == true`); none implement
-// typeAwareRule, so the engine runs them with a nil checker. The document
-// content comes entirely from `content` — the file on disk at opts.uri is
-// never read — so an editor can format an unsaved buffer without paying the
-// disk-copy + full-program-load cost of lspWorkspaceEditForCommand.
+// Built-in format rules are AST+source only and use the lightweight single-file
+// parser below. Contributor format rules conservatively require a checker, so
+// they use a temporary project seeded with `content`. Both branches derive
+// findings and edits from the supplied buffer; neither uses stale disk content
+// as the document or mutates the original project.
 //
 // Returns the same WorkspaceEdit shape as the disk path, or (nil, 0) on a
 // no-op (no fixable findings, or text unchanged after convergence).
@@ -471,32 +869,47 @@ func lspFormatBuffer(content string, opts *lspCommandOptions) (*lspWorkspaceEdit
   }
   // Guard rails mirror lspWorkspaceEditForCommand: skip targets outside the
   // project root or inside node_modules.
-  if _, ok := projectRelativePath(opts.cwd, target); !ok {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP command target %s is outside cwd %s\n", target, opts.cwd)
+  physicalCwd := realProjectPath(opts.cwd)
+  physicalTarget := realProjectPath(target)
+  if _, ok := projectRelativePath(physicalCwd, physicalTarget); !ok {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP command target %s is outside cwd %s\n", physicalTarget, physicalCwd)
     return nil, 2
   }
-  if projectPathHasSegment(opts.cwd, target, "node_modules") {
+  if lspProjectTargetHasSegment(opts, "node_modules") {
     return nil, 0
   }
 
-  rules, err := loadFormatRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  resolver, err := loadLSPCommandRules(
+    opts.pluginsJSON,
+    opts.cwd,
+    opts.tsconfig,
+    target,
+    true,
+  )
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, 2
   }
-  resolver, err := newFormatCommandResolver(rules, filepath.Dir(target), vscodeLanguageID(target))
-  if err != nil {
+  engine := NewEngineWithResolver(resolver)
+  if err := engine.ConfigError(); err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, 2
   }
-  engine := NewEngineWithResolver(resolver)
   if engine.NeedsTypeChecker() {
-    // A format-class contributor rule (formatContributorAdapter) needs the type
-    // checker, which the single-file in-memory parse can't supply. Fall back to
-    // the disk path, which builds a full program with a checker, so the result
-    // matches `ttsc format`; the dirty buffer can't be honored for these rules.
-    // Built-in format rules are AST-only, so they keep the fast in-memory path.
-    return lspWorkspaceEditForCommand(opts)
+    // Contributor format rules conservatively require a checker. Seed the
+    // dirty text into the temporary project so the checker, findings, fix
+    // ranges, and final WorkspaceEdit all describe the same editor document.
+    // Built-in AST-only format rules keep the fast single-file path below.
+    // Pass the LOGICAL target: the seeded command indexes it into the temp
+    // workspace (which mirrors the project's logical layout), so a
+    // project-internal symlink/junction must keep its logical name here too.
+    sourceOverlay := content
+    return lspWorkspaceEditForSeededCommand(
+      opts,
+      target,
+      content,
+      &sourceOverlay,
+    )
   }
   scriptKind := scriptKindForPath(target)
 
@@ -546,21 +959,23 @@ func scriptKindForPath(path string) shimcore.ScriptKind {
 }
 
 // applyFindingFixesToText is the in-memory counterpart of
-// applyFindingFixes/applyTextEditsToFile (fix.go): it collects every fixable
-// finding's TextEdit, selects a non-overlapping set with the same
-// selectTextEdits logic, applies them right-to-left to `text`, and returns the
-// new string plus the number of edits applied. It never writes to disk and
-// never reloads a Program. Findings carry byte offsets into the same `text`
-// that was just parsed, so no per-file grouping is needed.
+// applyFindingFixes/applyTextEditsToFile (fix.go): it groups every fixable
+// finding's edits, selects a non-overlapping, per-finding-atomic set with the
+// same selectTextEditGroups logic, applies them right-to-left to `text`, and
+// returns the new string plus the number of edits applied. It never writes to
+// disk and never reloads a Program. Findings carry byte offsets into the same
+// `text` that was just parsed, so no per-file grouping is needed — but each
+// finding still forms its own atomic edit group so a partially-overlapped
+// multi-edit fix is dropped whole rather than half-applied (samchon/ttsc#605).
 func applyFindingFixesToText(text string, findings []*Finding) (string, int) {
-  edits := make([]TextEdit, 0, len(findings))
+  groups := make([][]TextEdit, 0, len(findings))
   for _, finding := range findings {
     if finding == nil || len(finding.Fix) == 0 {
       continue
     }
-    edits = append(edits, finding.Fix...)
+    groups = append(groups, finding.Fix)
   }
-  selected := selectTextEdits(len(text), edits)
+  selected := selectTextEditGroups(len(text), groups)
   if len(selected) == 0 {
     return text, 0
   }
@@ -598,11 +1013,15 @@ func prepareLSPCommandWorkspace(cwd string, tsconfig string, target string) (str
     cleanup()
     return "", "", "", nil, fmt.Errorf("@ttsc/lint: LSP command target %s is outside cwd %s", target, cwd)
   }
-  if err := copyLSPCommandWorkspace(cwd, tempRoot); err != nil {
+  // Copy from the resolved (physical) cwd so a symlinked or short-name project
+  // root still descends into the real tree; the copy reproduces the project's
+  // LOGICAL layout, which tempPathFor above indexes into by the logical cwd.
+  physicalCwd := realProjectPath(cwd)
+  if err := copyLSPCommandWorkspace(physicalCwd, tempRoot); err != nil {
     cleanup()
     return "", "", "", nil, err
   }
-  if err := linkNearestNodeModules(tempRoot, cwd); err != nil {
+  if err := linkNearestNodeModules(tempRoot, physicalCwd); err != nil {
     cleanup()
     return "", "", "", nil, err
   }
@@ -633,7 +1052,11 @@ func copyLSPCommandWorkspace(src string, dst string) error {
       if entry.IsDir() {
         return filepath.SkipDir
       }
-      if entry.Type()&fs.ModeSymlink != 0 {
+      // A skipped directory that is a reparse point (a symlinked or junctioned
+      // node_modules/.git) is dropped without materializing its contents. A
+      // junction reports ModeSymlink on current toolchains and ModeIrregular on
+      // older ones, so check both bits.
+      if entry.Type()&(fs.ModeSymlink|fs.ModeIrregular) != 0 {
         return nil
       }
     }
@@ -652,28 +1075,34 @@ func copyLSPCommandWorkspaceEntry(src string, dst string, seenDirs map[string]st
     if err != nil {
       return err
     }
-    isSymlink := linkInfo.Mode()&os.ModeSymlink != 0
-    if isSymlink {
-      realDir, err := filepath.EvalSymlinks(src)
-      if err == nil {
-        if _, ok := seenDirs[realDir]; ok {
-          return nil
-        }
-        // Track the real path only for the active recursion branch.
-        // Releasing it on return lets sibling aliases pointing at the
-        // same real directory (e.g. `src-a -> real-src` and
-        // `src-b -> real-src` in different tsconfig entries) each get
-        // materialized; the test
-        // `TestLSPExecuteCommandMaterializesDuplicateSymlinkedDirectories`
-        // pins this contract.
-        seenDirs[realDir] = struct{}{}
-        defer delete(seenDirs, realDir)
+    // A directory that is itself a reparse point — a symlink OR an NTFS
+    // junction — is not descended into by filepath.WalkDir, so its contents
+    // must be materialized here under the LOGICAL name. Go reports a junction as
+    // ModeSymlink on current toolchains but as ModeIrregular on older ones;
+    // treat either bit as a link so the copy is correct regardless of version.
+    // A plain directory (neither bit) is created empty and left for WalkDir to
+    // descend (samchon/ttsc#614).
+    isLink := linkInfo.Mode()&(os.ModeSymlink|os.ModeIrregular) != 0
+    if isLink {
+      // resolveDirLink chases the symlink/junction via os.Readlink, which
+      // resolves junctions that neither ModeSymlink nor EvalSymlinks expose on
+      // older toolchains. The real path keys the cycle guard, scoped to the
+      // active recursion branch (defer delete) so sibling aliases pointing at
+      // one real directory (e.g. `src-a -> real-src` and `src-b -> real-src` in
+      // different tsconfig entries) each get materialized; the test
+      // `TestLSPExecuteCommandMaterializesDuplicateSymlinkedDirectories` pins
+      // this contract.
+      realDir := resolveDirLink(src)
+      if _, ok := seenDirs[realDir]; ok {
+        return nil
       }
+      seenDirs[realDir] = struct{}{}
+      defer delete(seenDirs, realDir)
     }
     if err := os.MkdirAll(dst, mode.Perm()); err != nil {
       return err
     }
-    if !isSymlink {
+    if !isLink {
       return nil
     }
     entries, err := os.ReadDir(src)
@@ -741,7 +1170,11 @@ func lspProjectTargetHasSegment(opts *lspCommandOptions, segment string) bool {
   if err != nil {
     return false
   }
-  return projectPathHasSegment(opts.cwd, target, segment)
+  if opts.projectIdentity.LogicalProjectRoot != "" &&
+    projectPathHasSegment(opts.projectIdentity.LogicalProjectRoot, target, segment) {
+    return true
+  }
+  return projectPathHasSegment(realProjectPath(opts.cwd), realProjectPath(target), segment)
 }
 
 func lspProjectTargetOutsideCwd(opts *lspCommandOptions) bool {
@@ -752,7 +1185,7 @@ func lspProjectTargetOutsideCwd(opts *lspCommandOptions) bool {
   if err != nil {
     return false
   }
-  _, ok := projectRelativePath(opts.cwd, target)
+  _, ok := projectRelativePath(realProjectPath(opts.cwd), realProjectPath(target))
   return !ok
 }
 
@@ -791,9 +1224,23 @@ func remapLSPPluginsJSONForTempWorkspace(raw string, cwd string, tempRoot string
   return string(next)
 }
 
+// tempPathFor maps a project `file` to its location inside the temp workspace,
+// which mirrors the project's LOGICAL layout. It therefore prefers the logical
+// relative path: a project-internal symlink or junction (src -> real-src),
+// materialized by copyLSPCommandWorkspace under its logical name, must be
+// addressed the same way here — resolving `file` physically would point at a
+// spelling (real-src/main.ts) the temp tree never created (samchon/ttsc#614).
+// Only when cwd and file don't share a logical prefix — an incidental boundary
+// alias such as a Windows 8.3 short cwd or macOS /tmp -> /private/tmp, where the
+// two spellings can independently pick either alias — does it fall back to
+// realProjectPath to reconcile them. Containment guards resolve physically and
+// live at the call sites, not here.
 func tempPathFor(cwd string, tempRoot string, file string) (string, bool) {
-  rel, err := filepath.Rel(cwd, file)
-  if err != nil || rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
+  if rel, ok := projectRelativePath(cwd, file); ok {
+    return filepath.Join(tempRoot, rel), true
+  }
+  rel, ok := projectRelativePath(realProjectPath(cwd), realProjectPath(file))
+  if !ok {
     return "", false
   }
   return filepath.Join(tempRoot, rel), true