ttsc 0.18.3 → 0.19.0

package/internal/lspserver/lsp_native_plugin_source.go

@@ -21,8 +21,9 @@ const nativePluginCommandStderrLimit = 1024 * 1024
 // passes through TTSC_LSP_PLUGINS_JSON after running normal project plugin
 // discovery and source-plugin builds.
 type NativePluginManifest struct {
-  Plugins    []NativePluginConfigEntry `json:"plugins"`
-  LSPPlugins []NativeLSPPluginEntry    `json:"lspPlugins"`
+  Plugins        []NativePluginConfigEntry `json:"plugins"`
+  LSPPlugins     []NativeLSPPluginEntry    `json:"lspPlugins"`
+  ProjectContext json.RawMessage           `json:"projectContext,omitempty"`
 }
 
 // NativePluginConfigEntry mirrors the compact sidecar protocol used by
@@ -36,9 +37,10 @@ type NativePluginConfigEntry struct {
 // NativeLSPPluginEntry names one built sidecar that opted into the LSP
 // protocol through its JavaScript descriptor capabilities.
 type NativeLSPPluginEntry struct {
-  Binary string `json:"binary"`
-  Name   string `json:"name,omitempty"`
-  Stage  string `json:"stage,omitempty"`
+  Binary             string `json:"binary"`
+  Name               string `json:"name,omitempty"`
+  ProjectContextArgs bool   `json:"projectContextArgs,omitempty"`
+  Stage              string `json:"stage,omitempty"`
 }
 
 // NativePluginSourceOptions configures a sidecar-backed PluginSource.
@@ -52,11 +54,12 @@ type NativePluginSourceOptions struct {
 // NativePluginSource implements PluginSource by delegating to native sidecars
 // that explicitly support ttsc's LSP subcommands.
 type NativePluginSource struct {
-  cwd         string
-  err         io.Writer
-  plugins     []NativeLSPPluginEntry
-  pluginsJSON string
-  tsconfig    string
+  cwd                string
+  err                io.Writer
+  plugins            []NativeLSPPluginEntry
+  pluginsJSON        string
+  projectContextJSON string
+  tsconfig           string
 
   commandIDs      []string
   codeActionKinds []string
@@ -110,40 +113,88 @@ func NewNativePluginSource(opts NativePluginSourceOptions) (*NativePluginSource,
   if err != nil {
     return nil, fmt.Errorf("ttscserver: encode plugin manifest: %w", err)
   }
+  sidecarCwd := opts.Cwd
+  sidecarTsconfig := opts.Tsconfig
+  if len(manifest.ProjectContext) > 0 {
+    var identity struct {
+      PhysicalConfigPath  string `json:"physicalConfigPath"`
+      PhysicalProjectRoot string `json:"physicalProjectRoot"`
+    }
+    if err := json.Unmarshal(manifest.ProjectContext, &identity); err != nil {
+      return nil, fmt.Errorf("ttscserver: decode project context: %w", err)
+    }
+    if strings.TrimSpace(identity.PhysicalProjectRoot) != "" {
+      sidecarCwd = identity.PhysicalProjectRoot
+    }
+    if strings.TrimSpace(identity.PhysicalConfigPath) != "" {
+      sidecarTsconfig = identity.PhysicalConfigPath
+    }
+  }
   source := &NativePluginSource{
-    cwd:         opts.Cwd,
-    err:         opts.Err,
-    plugins:     manifest.LSPPlugins,
-    pluginsJSON: string(pluginsJSON),
-    tsconfig:    opts.Tsconfig,
-    owners:      map[string]NativeLSPPluginEntry{},
+    cwd:                sidecarCwd,
+    err:                opts.Err,
+    plugins:            manifest.LSPPlugins,
+    pluginsJSON:        string(pluginsJSON),
+    projectContextJSON: string(manifest.ProjectContext),
+    tsconfig:           sidecarTsconfig,
+    owners:             map[string]NativeLSPPluginEntry{},
   }
   source.discoverCommandIDs()
   return source, nil
 }
 
-// Diagnostics asks every LSP-capable sidecar for diagnostics matching doc.URI.
-func (s *NativePluginSource) Diagnostics(doc LSPDocumentVersion) []LSPDiagnostic {
+// Diagnostics asks every LSP-capable sidecar for document diagnostics and its
+// separate project publication.
+func (s *NativePluginSource) Diagnostics(doc LSPDocumentVersion) LSPDiagnosticsResult {
   if s == nil || doc.URI == "" {
-    return nil
+    return LSPDiagnosticsResult{}
   }
-  var out []LSPDiagnostic
+  out := LSPDiagnosticsResult{}
   for _, plugin := range s.plugins {
     body, err := s.run(plugin, "lsp-diagnostics", "--uri="+doc.URI)
     if err != nil {
       s.log("%v", err)
       continue
     }
-    var diagnostics []LSPDiagnostic
-    if err := json.Unmarshal(body, &diagnostics); err != nil {
+    result, err := decodeNativeDiagnostics(body)
+    if err != nil {
       s.log("ttscserver: %s lsp-diagnostics returned invalid JSON: %v", pluginLabel(plugin), err)
       continue
     }
-    out = append(out, diagnostics...)
+    out.Document = append(out.Document, result.Document...)
+    if result.Project == nil {
+      continue
+    }
+    if out.Project == nil {
+      copied := *result.Project
+      copied.Diagnostics = append([]LSPDiagnostic(nil), result.Project.Diagnostics...)
+      out.Project = &copied
+      continue
+    }
+    if out.Project.URI != result.Project.URI {
+      s.log("ttscserver: %s returned project diagnostics for %s after %s; replacing the prior project publication", pluginLabel(plugin), result.Project.URI, out.Project.URI)
+      copied := *result.Project
+      copied.Diagnostics = append([]LSPDiagnostic(nil), result.Project.Diagnostics...)
+      out.Project = &copied
+      continue
+    }
+    out.Project.Diagnostics = append(out.Project.Diagnostics, result.Project.Diagnostics...)
   }
   return out
 }
 
+func decodeNativeDiagnostics(body []byte) (LSPDiagnosticsResult, error) {
+  var result LSPDiagnosticsResult
+  if err := json.Unmarshal(body, &result); err == nil {
+    return result, nil
+  }
+  var legacy []LSPDiagnostic
+  if err := json.Unmarshal(body, &legacy); err != nil {
+    return LSPDiagnosticsResult{}, err
+  }
+  return LSPDiagnosticsResult{Document: legacy}, nil
+}
+
 // CodeActions asks every LSP-capable sidecar for actions matching the request.
 func (s *NativePluginSource) CodeActions(uri string, rng LSPRange, ctx LSPCodeActionContext) []LSPCodeAction {
   if s == nil || uri == "" {
@@ -353,6 +404,9 @@ func (s *NativePluginSource) runWithStdin(plugin NativeLSPPluginEntry, command s
     "--tsconfig=" + s.tsconfig,
     "--plugins-json=" + s.pluginsJSON,
   }
+  if plugin.ProjectContextArgs && strings.TrimSpace(s.projectContextJSON) != "" {
+    allArgs = append(allArgs, "--project-context-json="+s.projectContextJSON)
+  }
   allArgs = append(allArgs, args...)
   cmd := exec.CommandContext(ctx, plugin.Binary, allArgs...)
   cmd.Dir = s.cwd

package/internal/lspserver/lsp_plugin.go

@@ -100,6 +100,21 @@ type LSPDocumentVersion struct {
   Version *int
 }
 
+// LSPProjectDiagnostics is one project-scoped diagnostic publication. URI is
+// the logical selected config URI and Diagnostics use a zero-width start range.
+type LSPProjectDiagnostics struct {
+  URI         string          `json:"uri"`
+  Diagnostics []LSPDiagnostic `json:"diagnostics"`
+}
+
+// LSPDiagnosticsResult separates diagnostics for the requested document from
+// the current project publication so the proxy never copies a project finding
+// onto every open source document.
+type LSPDiagnosticsResult struct {
+  Document []LSPDiagnostic        `json:"document"`
+  Project  *LSPProjectDiagnostics `json:"project,omitempty"`
+}
+
 // PluginSource is the seam between the LSP proxy and ttsc's plugin
 // pipeline. Returning empty slices/nil is a valid "no contribution"
 // answer; ttscserver still forwards the upstream tsgo response verbatim.
@@ -112,7 +127,7 @@ type PluginSource interface {
   // the field. The proxy appends these to whatever upstream tsgo
   // published, so duplicates between ttsc and tsgo must be deduplicated
   // on the source side.
-  Diagnostics(doc LSPDocumentVersion) []LSPDiagnostic
+  Diagnostics(doc LSPDocumentVersion) LSPDiagnosticsResult
 
   // CodeActions contributes additional actions for the given range. The
   // proxy appends them to upstream responses, or answers locally when
@@ -138,7 +153,9 @@ type PluginSource interface {
 type NullPluginSource struct{}
 
 // Diagnostics returns no plugin diagnostics.
-func (NullPluginSource) Diagnostics(LSPDocumentVersion) []LSPDiagnostic { return nil }
+func (NullPluginSource) Diagnostics(LSPDocumentVersion) LSPDiagnosticsResult {
+  return LSPDiagnosticsResult{}
+}
 
 // CodeActions returns no plugin code actions.
 func (NullPluginSource) CodeActions(string, LSPRange, LSPCodeActionContext) []LSPCodeAction {

package/internal/lspserver/lsp_proxy.go

@@ -44,6 +44,11 @@ const (
 // formats the live (possibly dirty) buffer rather than the on-disk file.
 const formatDocumentCommand = "ttsc.format.document"
 
+// utf8BOM is the UTF-8 byte-order mark (U+FEFF, bytes EF BB BF). It is stripped
+// from both the on-disk bytes and the editor buffer before a clean/dirty
+// comparison so a BOM present on only one side does not read as an edit.
+const utf8BOM = "\uFEFF"
+
 // ProxyOptions wires the byte-level proxy together. ttscserver creates
 // the upstream pipes around `tsgo --lsp --stdio` and hands the proxy
 // editor stdio plus those pipe ends.
@@ -64,10 +69,18 @@ type ProxyOptions struct {
   // avoid collisions; incoming prefixed ids are mapped back before dispatch.
   ExecuteCommandIDPrefix string
   // SymbolProvider answers textDocument/documentSymbol and
-  // textDocument/references locally from ttsc's compiler-backed code graph.
-  // When nil the proxy forwards those methods to upstream tsgo (its default
-  // behavior), which does not implement them.
+  // textDocument/references from ttsc's compiler-backed code graph. tsgo
+  // implements both methods, so the proxy forwards to tsgo whenever it
+  // advertises the capability and consults this provider only as a fallback
+  // (tsgo did not advertise) or when ForceLocalSymbolProvider is set. Nil leaves
+  // both methods forwarded to tsgo unconditionally.
   SymbolProvider SymbolProvider
+  // ForceLocalSymbolProvider answers documentSymbol/references from
+  // SymbolProvider even when upstream tsgo advertises the capability. It serves
+  // a raw-LSP graph consumer (such as @samchon/graph) that wants graph-derived
+  // declarations and usages instead of tsgo's language-service answers. Ignored
+  // when SymbolProvider is nil.
+  ForceLocalSymbolProvider bool
 }
 
 // Proxy bridges the editor and an upstream tsgo LSP process, intercepting
@@ -83,6 +96,7 @@ type Proxy struct {
   suppressedExecuteCommandIDs    map[string]struct{}
   executeCommandIDPrefix         string
   symbolProvider                 SymbolProvider
+  forceLocalSymbolProvider       bool
 
   writeMu         sync.Mutex // serializes WriteFrame calls to editorOut
   upstreamWriteMu sync.Mutex // serializes writes to upstreamIn
@@ -95,16 +109,21 @@ type Proxy struct {
   pendingCommands          map[string]struct{}
   pendingInitialize        map[string]struct{}
 
-  capabilityMu               sync.Mutex
-  upstreamCodeActionProvider bool
-
-  diagnosticsMu        sync.Mutex
-  upstreamDiagnostics  map[string]cachedDiagnostics
-  pluginDiagnostics    map[string]cachedDiagnostics
-  diagnosticGeneration map[string]uint64
-  documentGeneration   map[string]uint64
-  dirtyDocuments       map[string]struct{}
-  dirtyVersions        map[string]*int
+  capabilityMu                   sync.Mutex
+  upstreamCodeActionProvider     bool
+  upstreamDocumentSymbolProvider bool
+  upstreamReferencesProvider     bool
+
+  diagnosticsMu               sync.Mutex
+  upstreamDiagnostics         map[string]cachedDiagnostics
+  pluginDiagnostics           map[string]cachedDiagnostics
+  projectDiagnostics          cachedDiagnostics
+  projectDiagnosticsURI       string
+  projectDiagnosticGeneration uint64
+  diagnosticGeneration        map[string]uint64
+  documentGeneration          map[string]uint64
+  dirtyDocuments              map[string]struct{}
+  dirtyVersions               map[string]*int
   // documentText caches the live editor buffer per uri so the
   // textDocument/formatting handler can format the in-memory text instead
   // of the on-disk file. didOpen / full-sync didChange seed it with the full
@@ -152,6 +171,7 @@ func NewProxy(opts ProxyOptions) *Proxy {
     suppressedExecuteCommandIDs:    commandIDSet(opts.SuppressedExecuteCommandIDs),
     executeCommandIDPrefix:         opts.ExecuteCommandIDPrefix,
     symbolProvider:                 opts.SymbolProvider,
+    forceLocalSymbolProvider:       opts.ForceLocalSymbolProvider,
     asyncErrCh:                     make(chan error, 1),
     pendingActions:                 make(map[string]pendingCodeActionRequest),
     pendingAugmentingActions:       make(map[string]struct{}),
@@ -268,10 +288,12 @@ func (p *Proxy) handleEditorEnvelope(env Envelope, body []byte) (bool, error) {
     }
   case methodDidSave:
     if env.IsNotification() {
+      p.invalidateSymbolProvider()
       p.publishPluginDiagnosticsForDocumentNotification(env)
     }
   case methodDidChange:
     if env.IsNotification() {
+      p.invalidateSymbolProvider()
       p.cacheDidChangeText(env)
       if err := p.markDocumentDirty(env); err != nil {
         return false, err
@@ -427,6 +449,16 @@ func (p *Proxy) takePendingCommand(key string) bool {
   return true
 }
 
+type codeActionPositionWire struct {
+  Line      *int `json:"line"`
+  Character *int `json:"character"`
+}
+
+type codeActionRangeWire struct {
+  Start *codeActionPositionWire `json:"start"`
+  End   *codeActionPositionWire `json:"end"`
+}
+
 // decodeCodeActionRequest extracts the request payload so the matching
 // response from upstream can be augmented with ttsc-owned code actions
 // for the same range.
@@ -435,15 +467,37 @@ func (p *Proxy) decodeCodeActionRequest(env Envelope) (pendingCodeActionRequest,
     TextDocument struct {
       URI string `json:"uri"`
     } `json:"textDocument"`
-    Range   LSPRange             `json:"range"`
+    Range   *codeActionRangeWire `json:"range"`
     Context LSPCodeActionContext `json:"context"`
   }
   if err := json.Unmarshal(env.Params, &params); err != nil {
     return pendingCodeActionRequest{}, false
   }
+  if params.TextDocument.URI == "" || params.Range == nil ||
+    params.Range.Start == nil || params.Range.End == nil ||
+    params.Range.Start.Line == nil || params.Range.Start.Character == nil ||
+    params.Range.End.Line == nil || params.Range.End.Character == nil {
+    return pendingCodeActionRequest{}, false
+  }
+  rng := LSPRange{
+    Start: LSPPosition{
+      Line:      *params.Range.Start.Line,
+      Character: *params.Range.Start.Character,
+    },
+    End: LSPPosition{
+      Line:      *params.Range.End.Line,
+      Character: *params.Range.End.Character,
+    },
+  }
+  if rng.Start.Line < 0 || rng.Start.Character < 0 ||
+    rng.End.Line < 0 || rng.End.Character < 0 ||
+    rng.Start.Line > rng.End.Line ||
+    (rng.Start.Line == rng.End.Line && rng.Start.Character > rng.End.Character) {
+    return pendingCodeActionRequest{}, false
+  }
   return pendingCodeActionRequest{
     uri: params.TextDocument.URI,
-    rng: params.Range,
+    rng: rng,
     ctx: params.Context,
   }, true
 }
@@ -928,9 +982,9 @@ func (p *Proxy) prepareUpstreamPublishDiagnostics(env Envelope) func() {
     return nil
   }
   p.rememberUpstreamDiagnostics(params.URI, params.Version, params.Diagnostics)
-  generation := p.nextPluginDiagnosticsGeneration(params.URI)
+  generation, projectGeneration := p.nextDiagnosticsGenerations(params.URI)
   return func() {
-    p.publishMergedPluginDiagnostics(params.URI, params.Version, true, generation)
+    p.publishMergedPluginDiagnostics(params.URI, params.Version, true, generation, projectGeneration)
   }
 }
 
@@ -945,8 +999,8 @@ func (p *Proxy) publishPluginDiagnosticsForDocumentNotification(env Envelope) {
     return
   }
   p.markDocumentClean(params.TextDocument.URI)
-  generation := p.nextPluginDiagnosticsGeneration(params.TextDocument.URI)
-  go p.publishMergedPluginDiagnostics(params.TextDocument.URI, params.TextDocument.Version, false, generation)
+  generation, projectGeneration := p.nextDiagnosticsGenerations(params.TextDocument.URI)
+  go p.publishMergedPluginDiagnostics(params.TextDocument.URI, params.TextDocument.Version, false, generation, projectGeneration)
 }
 
 func (p *Proxy) publishPluginDiagnosticsForDidOpen(env Envelope) error {
@@ -967,12 +1021,12 @@ func (p *Proxy) publishPluginDiagnosticsForDidOpen(env Envelope) error {
     return nil
   }
   p.markDocumentClean(params.TextDocument.URI)
-  generation := p.nextPluginDiagnosticsGeneration(params.TextDocument.URI)
-  go p.publishMergedPluginDiagnostics(params.TextDocument.URI, params.TextDocument.Version, false, generation)
+  generation, projectGeneration := p.nextDiagnosticsGenerations(params.TextDocument.URI)
+  go p.publishMergedPluginDiagnostics(params.TextDocument.URI, params.TextDocument.Version, false, generation, projectGeneration)
   return nil
 }
 
-func (p *Proxy) publishMergedPluginDiagnostics(uri string, version *int, adoptCachedVersion bool, generation uint64) {
+func (p *Proxy) publishMergedPluginDiagnostics(uri string, version *int, adoptCachedVersion bool, generation uint64, projectGeneration uint64) {
   if !p.isLatestPluginDiagnosticsGeneration(uri, generation) || p.isDocumentDirty(uri) {
     return
   }
@@ -980,11 +1034,13 @@ func (p *Proxy) publishMergedPluginDiagnostics(uri string, version *int, adoptCa
     URI:     uri,
     Version: version,
   })
-  version, merged, ok := p.prepareMergedPluginDiagnostics(uri, version, adoptCachedVersion, generation, diagnostics)
-  if !ok {
-    return
+  version, merged, ok := p.prepareMergedPluginDiagnostics(uri, version, adoptCachedVersion, generation, diagnostics.Document)
+  if ok {
+    p.reportAsyncError(p.writePublishDiagnosticsIfCurrent(uri, version, merged, generation))
+  }
+  if diagnostics.Project != nil {
+    p.reportAsyncError(p.writeProjectDiagnosticsIfCurrent(diagnostics.Project, projectGeneration))
   }
-  p.reportAsyncError(p.writePublishDiagnosticsIfCurrent(uri, version, merged, generation))
 }
 
 func (p *Proxy) writePublishDiagnostics(uri string, version *int, diagnostics []json.RawMessage) error {
@@ -1005,6 +1061,71 @@ func (p *Proxy) writePublishDiagnosticsIfCurrent(uri string, version *int, diagn
   return WriteFrame(p.editorOut, body)
 }
 
+func (p *Proxy) writeProjectDiagnosticsIfCurrent(publication *LSPProjectDiagnostics, generation uint64) error {
+  if publication == nil || publication.URI == "" {
+    return nil
+  }
+  diagnostics := append([]LSPDiagnostic(nil), publication.Diagnostics...)
+  for index := range diagnostics {
+    diagnostics[index].Range = LSPRange{}
+  }
+  rawDiagnostics := marshalLSPDiagnostics(diagnostics)
+  p.writeMu.Lock()
+  defer p.writeMu.Unlock()
+  p.diagnosticsMu.Lock()
+  defer p.diagnosticsMu.Unlock()
+  if p.projectDiagnosticGeneration != generation {
+    return nil
+  }
+
+  previousURI := p.projectDiagnosticsURI
+  previousHadDiagnostics := len(p.projectDiagnostics.diagnostics) > 0
+  changedURI := previousURI != "" && previousURI != publication.URI
+  if changedURI {
+    p.projectDiagnosticsURI = ""
+    p.projectDiagnostics = cachedDiagnostics{}
+    if err := WriteFrame(
+      p.editorOut,
+      p.publishDiagnosticsBody(previousURI, nil, p.mergedDiagnosticsLocked(previousURI)),
+    ); err != nil {
+      return err
+    }
+  }
+
+  p.projectDiagnosticsURI = publication.URI
+  p.projectDiagnostics = cachedDiagnostics{diagnostics: copyRawDiagnostics(rawDiagnostics)}
+  if len(rawDiagnostics) == 0 && !previousHadDiagnostics && !changedURI {
+    return nil
+  }
+  return WriteFrame(
+    p.editorOut,
+    p.publishDiagnosticsBody(publication.URI, nil, p.mergedDiagnosticsLocked(publication.URI)),
+  )
+}
+
+func marshalLSPDiagnostics(diagnostics []LSPDiagnostic) []json.RawMessage {
+  rawDiagnostics := make([]json.RawMessage, 0, len(diagnostics))
+  for _, diagnostic := range diagnostics {
+    raw, _ := json.Marshal(diagnostic)
+    rawDiagnostics = append(rawDiagnostics, raw)
+  }
+  return rawDiagnostics
+}
+
+func (p *Proxy) mergedDiagnosticsLocked(uri string) []json.RawMessage {
+  upstream := p.upstreamDiagnostics[uri].diagnostics
+  document := p.pluginDiagnostics[uri].diagnostics
+  project := []json.RawMessage(nil)
+  if p.projectDiagnosticsURI == uri {
+    project = p.projectDiagnostics.diagnostics
+  }
+  merged := make([]json.RawMessage, 0, len(upstream)+len(document)+len(project))
+  merged = append(merged, copyRawDiagnostics(upstream)...)
+  merged = append(merged, copyRawDiagnostics(document)...)
+  merged = append(merged, copyRawDiagnostics(project)...)
+  return merged
+}
+
 func (p *Proxy) writeLocalCodeActionsResultIfCurrent(id json.RawMessage, actions []LSPCodeAction, pending pendingCodeActionRequest) error {
   p.writeMu.Lock()
   defer p.writeMu.Unlock()
@@ -1288,6 +1409,7 @@ func (p *Proxy) markDocumentDirtyURI(uri string, version *int) bool {
   delete(p.pluginDiagnostics, uri)
   delete(p.upstreamDiagnostics, uri)
   p.diagnosticGeneration[uri]++
+  p.projectDiagnosticGeneration++
   p.documentGeneration[uri]++
   return len(previous.diagnostics) > 0
 }
@@ -1338,7 +1460,14 @@ func documentTextMatchesDisk(uri string, text string) bool {
     return false
   }
   disk, err := os.ReadFile(file)
-  return err == nil && string(disk) == text
+  if err != nil {
+    return false
+  }
+  // Editors commonly strip a leading UTF-8 BOM from the buffer text they send
+  // while it stays on disk (or add one the disk lacks). A raw byte compare would
+  // then misclassify an unedited file as dirty and suppress plugin diagnostics
+  // until the first save, so a single leading BOM is dropped from both sides.
+  return strings.TrimPrefix(string(disk), utf8BOM) == strings.TrimPrefix(text, utf8BOM)
 }
 
 func filePathFromURI(raw string) (string, bool) {
@@ -1363,12 +1492,13 @@ func filePathFromURI(raw string) (string, bool) {
   return abs, true
 }
 
-func (p *Proxy) nextPluginDiagnosticsGeneration(uri string) uint64 {
+func (p *Proxy) nextDiagnosticsGenerations(uri string) (uint64, uint64) {
   p.diagnosticsMu.Lock()
   defer p.diagnosticsMu.Unlock()
   next := p.diagnosticGeneration[uri] + 1
   p.diagnosticGeneration[uri] = next
-  return next
+  p.projectDiagnosticGeneration++
+  return next, p.projectDiagnosticGeneration
 }
 
 func (p *Proxy) isLatestPluginDiagnosticsGeneration(uri string, generation uint64) bool {
@@ -1401,11 +1531,7 @@ func (p *Proxy) prepareMergedPluginDiagnostics(
   if uri == "" {
     return nil, nil, false
   }
-  rawDiagnostics := make([]json.RawMessage, 0, len(diagnostics))
-  for _, diagnostic := range diagnostics {
-    raw, _ := json.Marshal(diagnostic)
-    rawDiagnostics = append(rawDiagnostics, raw)
-  }
+  rawDiagnostics := marshalLSPDiagnostics(diagnostics)
   inputVersion := copyIntPtr(version)
 
   p.diagnosticsMu.Lock()
@@ -1433,10 +1559,7 @@ func (p *Proxy) prepareMergedPluginDiagnostics(
   if len(rawDiagnostics) == 0 && !previousPluginDiagnostics {
     return nil, nil, false
   }
-  cachedDiagnostics := copyRawDiagnostics(cached.diagnostics)
-  merged := make([]json.RawMessage, 0, len(cachedDiagnostics)+len(rawDiagnostics))
-  merged = append(merged, cachedDiagnostics...)
-  merged = append(merged, rawDiagnostics...)
+  merged := p.mergedDiagnosticsLocked(uri)
   return copyIntPtr(version), merged, true
 }
 
@@ -1483,6 +1606,11 @@ func (p *Proxy) augmentInitializeResult(env Envelope) ([]byte, bool) {
   }
   codeActionProvider := caps["codeActionProvider"]
   p.setUpstreamCodeActionProvider(codeActionProvider)
+  // Record whether upstream tsgo answers documentSymbol/references itself. The
+  // per-method handlers forward to tsgo when it does, so this must be set before
+  // the shouldAnswer* checks below read it.
+  p.setUpstreamDocumentSymbolProvider(caps["documentSymbolProvider"])
+  p.setUpstreamReferencesProvider(caps["referencesProvider"])
   codeActionKinds := p.pluginCodeActionKinds()
   changed := false
   if (len(sourceCommands) > 0 || len(codeActionKinds) > 0) && codeActionProvider == nil {
@@ -1516,20 +1644,19 @@ func (p *Proxy) augmentInitializeResult(env Envelope) ([]byte, bool) {
       changed = true
     }
   }
-  // Advertise documentSymbol/references when a local SymbolProvider is wired so
-  // graph consumers know to call them. The proxy intercepts both methods
-  // (handleEditorEnvelope) whether or not upstream tsgo advertised them, so
-  // forcing the capability on is safe: tsgo's own (incomplete) handlers are
-  // never reached for these methods.
-  if p.symbolProvider != nil {
-    if existing, ok := caps["documentSymbolProvider"].(bool); !ok || !existing {
-      caps["documentSymbolProvider"] = true
-      changed = true
-    }
-    if existing, ok := caps["referencesProvider"].(bool); !ok || !existing {
-      caps["referencesProvider"] = true
-      changed = true
-    }
+  // Advertise documentSymbol/references only when the proxy will actually answer
+  // them locally — upstream tsgo did not advertise the capability (fallback) or
+  // ForceLocalSymbolProvider is set. When tsgo advertises and the flag is off,
+  // the method is forwarded to tsgo, whose own capability already tells the
+  // editor to send the request, so its (possibly richer) capability is left
+  // untouched here.
+  if p.shouldAnswerDocumentSymbolLocally() && !capabilityAdvertised(caps["documentSymbolProvider"]) {
+    caps["documentSymbolProvider"] = true
+    changed = true
+  }
+  if p.shouldAnswerReferencesLocally() && !capabilityAdvertised(caps["referencesProvider"]) {
+    caps["referencesProvider"] = true
+    changed = true
   }
   if !changed {
     return nil, false
@@ -1635,6 +1762,71 @@ func (p *Proxy) setUpstreamCodeActionProvider(value any) {
   p.upstreamCodeActionProvider = provides
 }
 
+func (p *Proxy) setUpstreamDocumentSymbolProvider(value any) {
+  p.capabilityMu.Lock()
+  defer p.capabilityMu.Unlock()
+  p.upstreamDocumentSymbolProvider = capabilityAdvertised(value)
+}
+
+func (p *Proxy) setUpstreamReferencesProvider(value any) {
+  p.capabilityMu.Lock()
+  defer p.capabilityMu.Unlock()
+  p.upstreamReferencesProvider = capabilityAdvertised(value)
+}
+
+// shouldAnswerDocumentSymbolLocally reports whether the proxy answers
+// textDocument/documentSymbol from the local SymbolProvider instead of
+// forwarding to upstream tsgo: a provider must be wired, and either the caller
+// forced it or tsgo did not advertise the capability.
+func (p *Proxy) shouldAnswerDocumentSymbolLocally() bool {
+  if p.symbolProvider == nil {
+    return false
+  }
+  if p.forceLocalSymbolProvider {
+    return true
+  }
+  p.capabilityMu.Lock()
+  defer p.capabilityMu.Unlock()
+  return !p.upstreamDocumentSymbolProvider
+}
+
+// shouldAnswerReferencesLocally mirrors shouldAnswerDocumentSymbolLocally for
+// textDocument/references.
+func (p *Proxy) shouldAnswerReferencesLocally() bool {
+  if p.symbolProvider == nil {
+    return false
+  }
+  if p.forceLocalSymbolProvider {
+    return true
+  }
+  p.capabilityMu.Lock()
+  defer p.capabilityMu.Unlock()
+  return !p.upstreamReferencesProvider
+}
+
+// invalidateSymbolProvider drops the SymbolProvider's cached compiler state so
+// the next documentSymbol/references request reflects the latest sources. It is
+// a no-op when no provider is wired.
+func (p *Proxy) invalidateSymbolProvider() {
+  if p.symbolProvider != nil {
+    p.symbolProvider.Invalidate()
+  }
+}
+
+// capabilityAdvertised reports whether an LSP server-capability value means the
+// server implements the capability: boolean true, or an options object. Absent
+// (nil), false, or any other shape counts as unsupported.
+func capabilityAdvertised(value any) bool {
+  switch v := value.(type) {
+  case bool:
+    return v
+  case map[string]any:
+    return v != nil
+  default:
+    return false
+  }
+}
+
 func mergeCommandIDs(existing any, additions []string) []string {
   seen := map[string]struct{}{}
   out := make([]string, 0, len(additions))