ttsc 0.20.1 → 0.22.0

package/internal/lspserver/lsp_native_plugin_source.go

@@ -10,6 +10,7 @@ import (
   "os/exec"
   "strings"
   "sync"
+  "sync/atomic"
   "time"
 )
 
@@ -18,12 +19,13 @@ const nativePluginCommandStdoutLimit = 4 * 1024 * 1024
 const nativePluginCommandStderrLimit = 1024 * 1024
 
 // NativePluginManifest is the JSON shape the JavaScript ttscserver launcher
-// passes through TTSC_LSP_PLUGINS_JSON after running normal project plugin
+// writes to its private manifest file after running normal project plugin
 // discovery and source-plugin builds.
 type NativePluginManifest struct {
-  Plugins        []NativePluginConfigEntry `json:"plugins"`
-  LSPPlugins     []NativeLSPPluginEntry    `json:"lspPlugins"`
-  ProjectContext json.RawMessage           `json:"projectContext,omitempty"`
+  InitialProjectInputs map[string]LSPProjectInputSnapshot `json:"initialProjectInputs,omitempty"`
+  Plugins              []NativePluginConfigEntry          `json:"plugins"`
+  LSPPlugins           []NativeLSPPluginEntry             `json:"lspPlugins"`
+  ProjectContext       json.RawMessage                    `json:"projectContext,omitempty"`
 }
 
 // NativePluginConfigEntry mirrors the compact sidecar protocol used by
@@ -37,10 +39,14 @@ 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"`
-  ProjectContextArgs bool   `json:"projectContextArgs,omitempty"`
-  Stage              string `json:"stage,omitempty"`
+  Binary                 string                   `json:"binary"`
+  InitialProjectInputKey string                   `json:"initialProjectInputKey,omitempty"`
+  InitialProjectInputs   *LSPProjectInputSnapshot `json:"initialProjectInputs,omitempty"`
+  Name                   string                   `json:"name,omitempty"`
+  ProjectDiagnostics     bool                     `json:"projectDiagnostics,omitempty"`
+  ProjectInputs          bool                     `json:"projectInputs,omitempty"`
+  ProjectContextArgs     bool                     `json:"projectContextArgs,omitempty"`
+  Stage                  string                   `json:"stage,omitempty"`
 }
 
 // NativePluginSourceOptions configures a sidecar-backed PluginSource.
@@ -60,6 +66,15 @@ type NativePluginSource struct {
   pluginsJSON        string
   projectContextJSON string
   tsconfig           string
+  clientTsconfig     string
+  clientCwd          string
+
+  // The client's project resolves once. Both halves are fixed for the
+  // session, while the answer costs a symlink walk per ancestor, and the
+  // question is asked again for every producer on every publication.
+  clientProjectOnce sync.Once
+  clientProject     string
+  clientProjectKey  string
 
   commandIDs      []string
   codeActionKinds []string
@@ -88,6 +103,16 @@ type NativePluginSource struct {
   owners       map[string]NativeLSPPluginEntry
   logMu        sync.Mutex
 
+  projectInputsMu       sync.RWMutex
+  projectInputs         LSPProjectInputSnapshot
+  pluginProjectInputs   map[string]projectInputRecord
+  projectInputsObserver func()
+  projectInputsRefresh  coalescingRefresh
+
+  projectDiagnosticsMu       sync.RWMutex
+  pluginProjectDiagnostics   map[string]projectDiagnosticRecord
+  projectDiagnosticsSequence atomic.Uint64
+
   // residentMu guards the resident-daemon table below. A resident sidecar keeps
   // a warm Program across verbs, so lsp-diagnostics / lsp-code-actions reuse it
   // instead of respawning per verb; serveUnsupported remembers a sidecar that
@@ -136,7 +161,9 @@ func NewNativePluginSource(opts NativePluginSourceOptions) (*NativePluginSource,
   var manifest NativePluginManifest
   if strings.TrimSpace(opts.ManifestJSON) != "" {
     if err := json.Unmarshal([]byte(opts.ManifestJSON), &manifest); err != nil {
-      return nil, fmt.Errorf("ttscserver: invalid TTSC_LSP_PLUGINS_JSON: %w", err)
+      // The manifest reaches this constructor through three transports, so it
+      // is named by what it is rather than by the one that happened to carry it.
+      return nil, fmt.Errorf("ttscserver: invalid LSP plugin manifest: %w", err)
     }
   }
   pluginsJSON, err := json.Marshal(manifest.Plugins)
@@ -167,9 +194,57 @@ func NewNativePluginSource(opts NativePluginSourceOptions) (*NativePluginSource,
     pluginsJSON:        string(pluginsJSON),
     projectContextJSON: string(manifest.ProjectContext),
     tsconfig:           sidecarTsconfig,
+    clientTsconfig:     opts.Tsconfig,
+    clientCwd:          opts.Cwd,
     owners:             map[string]NativeLSPPluginEntry{},
   }
   source.discoverCommandIDs()
+  missingInitialProjectInputs := false
+  for _, plugin := range selectPluginTransports(
+    source.plugins,
+    func(plugin NativeLSPPluginEntry) bool {
+      return plugin.ProjectInputs
+    },
+    source.projectContextJSON,
+  ) {
+    initialProjectInputs := plugin.InitialProjectInputs
+    if plugin.InitialProjectInputKey != "" {
+      snapshot, ok := manifest.InitialProjectInputs[plugin.InitialProjectInputKey]
+      if !ok {
+        return nil, fmt.Errorf(
+          "ttscserver: %s initial project inputs key %q is missing from the manifest",
+          pluginLabel(plugin),
+          plugin.InitialProjectInputKey,
+        )
+      }
+      initialProjectInputs = &snapshot
+    }
+    if initialProjectInputs == nil {
+      missingInitialProjectInputs = true
+      continue
+    }
+    snapshot, err := normalizeLSPProjectInputSnapshot(
+      *initialProjectInputs,
+      source.cwd,
+    )
+    if err != nil {
+      return nil, fmt.Errorf(
+        "ttscserver: %s initial project inputs are invalid: %w",
+        pluginLabel(plugin),
+        err,
+      )
+    }
+    if !projectInputReloadFingerprintsAreCurrent(snapshot) {
+      return nil, fmt.Errorf(
+        "ttscserver: %s project selection inputs changed during startup",
+        pluginLabel(plugin),
+      )
+    }
+    source.storeProjectInputs(plugin, 1, snapshot)
+  }
+  if missingInitialProjectInputs {
+    source.discoverProjectInputs(1)
+  }
   // The corpus fetch loads a Program, so it runs off the construction path.
   // Blocking here would delay initialize — and therefore the editor's first
   // response — for a feature most projects do not use. Until it lands,
@@ -188,8 +263,15 @@ func (s *NativePluginSource) Diagnostics(doc LSPDocumentVersion) LSPDiagnosticsR
   if s == nil || doc.URI == "" {
     return LSPDiagnosticsResult{}
   }
-  out := LSPDiagnosticsResult{}
-  for _, plugin := range s.plugins {
+  generation := s.projectDiagnosticsSequence.Add(1)
+  out := LSPDiagnosticsResult{
+    projectUpdatedProducers: map[string]struct{}{},
+  }
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
     body, err := s.run(plugin, "lsp-diagnostics", "--uri="+doc.URI)
     if err != nil {
       s.log("%v", err)
@@ -201,23 +283,13 @@ func (s *NativePluginSource) Diagnostics(doc LSPDocumentVersion) LSPDiagnosticsR
       continue
     }
     out.Document = append(out.Document, result.Document...)
-    if result.Project == nil {
-      continue
+    if result.Project != nil && result.Project.URI != "" {
+      s.storeProjectDiagnostics(plugin, generation, result.Project)
+      out.projectUpdatedProducers[pluginKey(plugin, s.projectContextJSON)] = struct{}{}
     }
-    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...)
+  }
+  if len(out.projectUpdatedProducers) != 0 {
+    out.Project = s.projectDiagnosticsSnapshot()
   }
   return out
 }
@@ -242,7 +314,11 @@ func (s *NativePluginSource) CodeActions(uri string, rng LSPRange, ctx LSPCodeAc
   rangeJSON, _ := json.Marshal(rng)
   contextJSON, _ := json.Marshal(ctx)
   var out []LSPCodeAction
-  for _, plugin := range s.plugins {
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
     body, err := s.run(
       plugin,
       "lsp-code-actions",
@@ -435,7 +511,11 @@ type completionHintRecord struct {
 // so a fast producer's fresh corpus reaches the editor without waiting on a slow
 // one, and a producer that failed keeps serving what it last published.
 func (s *NativePluginSource) discoverCompletionHints(generation uint64) {
-  for _, plugin := range s.plugins {
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
     body, err := s.run(plugin, "lsp-hints")
     if err != nil {
       // Silent, unlike every other discovery failure here. A plugin that does
@@ -474,7 +554,7 @@ func (s *NativePluginSource) discoverCompletionHints(generation uint64) {
 // being offered. An older generation is dropped: refresh cycles are scheduled by
 // editor events, and the last event's answer is the one the user is waiting for.
 func (s *NativePluginSource) storeCompletionHints(plugin NativeLSPPluginEntry, generation uint64, hints []LSPCompletionHint) {
-  key := pluginKey(plugin)
+  key := pluginKey(plugin, s.projectContextJSON)
   s.hintsMu.Lock()
   defer s.hintsMu.Unlock()
   if existing, ok := s.pluginHints[key]; ok && generation < existing.generation {
@@ -494,13 +574,12 @@ func (s *NativePluginSource) storeCompletionHints(plugin NativeLSPPluginEntry, g
 // which a Go map's randomized range would not. The caller holds hintsMu.
 func (s *NativePluginSource) flattenCompletionHintsLocked() []LSPCompletionHint {
   hints := []LSPCompletionHint{}
-  seen := make(map[string]struct{}, len(s.plugins))
-  for _, plugin := range s.plugins {
-    key := pluginKey(plugin)
-    if _, duplicate := seen[key]; duplicate {
-      continue
-    }
-    seen[key] = struct{}{}
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
+    key := pluginKey(plugin, s.projectContextJSON)
     hints = append(hints, s.pluginHints[key].hints...)
   }
   return hints
@@ -518,12 +597,44 @@ func (s *NativePluginSource) notifyCompletionHintsObserver() {
   }
 }
 
-// pluginKey identifies one manifest entry. It matches the identity
-// pluginOwnsCommand compares, so a manifest carrying the same binary under two
-// stages keeps two independent corpora instead of overwriting one with the
-// other.
-func pluginKey(plugin NativeLSPPluginEntry) string {
-  return plugin.Binary + "\x00" + plugin.Name + "\x00" + plugin.Stage
+// pluginKey identifies one effective native launch transport. Every LSP verb
+// receives the full plugin manifest and has no selected-entry argument, so two
+// logical entries using the same binary and project-context argv return one
+// aggregate result and must share one cache, owner scope, and resident daemon.
+func pluginKey(
+  plugin NativeLSPPluginEntry,
+  projectContextJSON ...string,
+) string {
+  projectContextArgs := "0"
+  if plugin.ProjectContextArgs &&
+    len(projectContextJSON) != 0 &&
+    strings.TrimSpace(projectContextJSON[0]) != "" {
+    projectContextArgs = "1"
+  }
+  return plugin.Binary + "\x00" + projectContextArgs
+}
+
+// selectPluginTransports preserves manifest order while selecting at most one
+// representative for each effective native launch identity.
+func selectPluginTransports(
+  plugins []NativeLSPPluginEntry,
+  include func(NativeLSPPluginEntry) bool,
+  projectContextJSON ...string,
+) []NativeLSPPluginEntry {
+  selected := make([]NativeLSPPluginEntry, 0, len(plugins))
+  seen := make(map[string]struct{}, len(plugins))
+  for _, plugin := range plugins {
+    if include != nil && !include(plugin) {
+      continue
+    }
+    key := pluginKey(plugin, projectContextJSON...)
+    if _, duplicate := seen[key]; duplicate {
+      continue
+    }
+    seen[key] = struct{}{}
+    selected = append(selected, plugin)
+  }
+  return selected
 }
 
 // decodeNativeCompletionHints accepts both generations of the lsp-hints wire.
@@ -616,7 +727,11 @@ func (s *NativePluginSource) CodeActionKinds() []string {
 func (s *NativePluginSource) discoverCommandIDs() {
   seen := map[string]struct{}{}
   kindSeen := map[string]struct{}{}
-  for _, plugin := range s.plugins {
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
     body, err := s.run(plugin, "lsp-command-ids")
     if err != nil {
       s.log("%v", err)
@@ -670,7 +785,8 @@ func (s *NativePluginSource) pluginOwnsCommand(plugin NativeLSPPluginEntry, comm
   if !ok {
     return false
   }
-  return owner.Binary == plugin.Binary && owner.Name == plugin.Name && owner.Stage == plugin.Stage
+  return pluginKey(owner, s.projectContextJSON) ==
+    pluginKey(plugin, s.projectContextJSON)
 }
 
 func (s *NativePluginSource) run(plugin NativeLSPPluginEntry, command string, args ...string) ([]byte, error) {
@@ -680,20 +796,20 @@ func (s *NativePluginSource) run(plugin NativeLSPPluginEntry, command string, ar
   // spawn-per-verb path below with no behavior change. The static discovery
   // verbs (lsp-command-ids / lsp-code-action-kinds) and lsp-execute-command stay
   // on exec by design.
-  if command == serveVerbDiagnostics || command == serveVerbCodeActions {
+  if command == serveVerbDiagnostics ||
+    command == serveVerbCodeActions {
     if body, served, err := s.serveRun(plugin, command, args); served {
       return body, err
     }
   }
-  if command == serveVerbHints {
-    // Hints join the daemon on a weaker condition than the other two: the
-    // answer is used only when it arrives without error. A sidecar built after
-    // the daemon landed but before this verb joined it answers lsp-serve and
-    // rejects lsp-hints as an unknown verb, which reaches this side as a
-    // nonzero code — indistinguishable over this protocol from a rule that
-    // failed. Falling back to the spawn path on any nonzero reply keeps that
-    // sidecar's corpus working, and a project whose hints genuinely fail pays
-    // one extra spawn to fail there too, exactly as it did before.
+  if command == serveVerbProjectDiagnostics ||
+    command == serveVerbHints {
+    // These newer optional verbs join the daemon on a weaker condition than the
+    // original document reads. A staged sidecar may implement the direct verb
+    // while its older resident loop rejects it. A nonzero resident reply is
+    // indistinguishable from the verb itself failing, so retry once through the
+    // advertised direct command. A genuine failure pays one extra spawn and is
+    // then handled exactly as it was before lsp-serve.
     if body, served, err := s.serveRun(plugin, command, args); served && err == nil {
       return body, nil
     }

package/internal/lspserver/lsp_native_resident.go

@@ -18,15 +18,16 @@ import (
 // the caller falls back to a fresh spawn.
 const residentRequestTimeout = nativePluginCommandTimeout
 
-// serveVerbDiagnostics, serveVerbCodeActions, and serveVerbHints are the verbs
-// routed to the resident daemon: the three that load a Program.
+// The serve verbs below are routed to the resident daemon because they load a
+// Program.
 // lsp-command-ids / lsp-code-action-kinds run once at startup and never load one
 // (routing them would spawn the daemon on the initialize path);
 // lsp-execute-command is user-initiated and keeps its spawn-per-verb path.
 const (
-  serveVerbDiagnostics = "lsp-diagnostics"
-  serveVerbCodeActions = "lsp-code-actions"
-  serveVerbHints       = "lsp-hints"
+  serveVerbDiagnostics        = "lsp-diagnostics"
+  serveVerbProjectDiagnostics = "lsp-project-diagnostics"
+  serveVerbCodeActions        = "lsp-code-actions"
+  serveVerbHints              = "lsp-hints"
 )
 
 // serveClientRequest mirrors linthost's serveLSPRequest: the base project
@@ -38,6 +39,7 @@ type serveClientRequest struct {
   ContextJSON string   `json:"contextJson,omitempty"`
   Invalidate  bool     `json:"invalidate,omitempty"`
   Changed     []string `json:"changed,omitempty"`
+  External    []string `json:"external,omitempty"`
 }
 
 // serveClientResponse mirrors linthost's serveLSPResponse: the verb's JSON
@@ -63,6 +65,9 @@ type residentSidecar struct {
   // request, so the daemon updates the warm Program incrementally rather than
   // rebuilding it.
   changed []string
+  // external identifies changed entries that are declared ProjectRule inputs,
+  // allowing an unknown non-Program path to retain the warm Program.
+  external []string
 }
 
 // serveRun routes a serve-able verb through the plugin's resident daemon.
@@ -75,18 +80,19 @@ func (s *NativePluginSource) serveRun(plugin NativeLSPPluginEntry, verb string,
   if s == nil || strings.TrimSpace(plugin.Binary) == "" {
     return nil, false, nil
   }
+  key := pluginKey(plugin, s.projectContextJSON)
   s.residentMu.Lock()
-  if s.serveUnsupported[plugin.Binary] {
+  if s.serveUnsupported[key] {
     s.residentMu.Unlock()
     return nil, false, nil
   }
-  sc := s.residents[plugin.Binary]
+  sc := s.residents[key]
   if sc == nil {
     sc = &residentSidecar{}
     if s.residents == nil {
       s.residents = map[string]*residentSidecar{}
     }
-    s.residents[plugin.Binary] = sc
+    s.residents[key] = sc
   }
   s.residentMu.Unlock()
 
@@ -103,7 +109,7 @@ func (s *NativePluginSource) serveRun(plugin NativeLSPPluginEntry, verb string,
       if s.serveUnsupported == nil {
         s.serveUnsupported = map[string]bool{}
       }
-      s.serveUnsupported[plugin.Binary] = true
+      s.serveUnsupported[key] = true
     }
     s.residentMu.Unlock()
     return nil, false, nil
@@ -133,6 +139,10 @@ func (sc *residentSidecar) call(s *NativePluginSource, plugin NativeLSPPluginEnt
     req.Changed = sc.changed
     sc.changed = nil
   }
+  if len(sc.external) > 0 {
+    req.External = sc.external
+    sc.external = nil
+  }
   line, err := json.Marshal(req)
   if err != nil {
     return nil, 0, err
@@ -250,6 +260,97 @@ func (s *NativePluginSource) InvalidateResidentPrograms(changedURIs ...string) {
   }
 }
 
+// InvalidateResidentProgramsForWatchedChanges distinguishes declared external
+// inputs from ordinary watched files so the sidecar can retain its Program for
+// data-only changes while still rebuilding fresh ProjectRule state.
+func (s *NativePluginSource) InvalidateResidentProgramsForWatchedChanges(
+  changedURIs []string,
+  externalURIs []string,
+) {
+  externalOwners := make(map[string][]string, len(externalURIs))
+  for _, uri := range externalURIs {
+    externalOwners[uri] = nil
+  }
+  s.InvalidateResidentProgramsForOwnedWatchedChanges(
+    changedURIs,
+    externalURIs,
+    externalOwners,
+  )
+}
+
+// InvalidateResidentProgramsForOwnedWatchedChanges sends data-only external
+// changes only to resident binaries that own the matching snapshot. A path that
+// can also belong to the Program reaches every resident, because each daemon
+// must decide whether its own Program contains that source.
+func (s *NativePluginSource) InvalidateResidentProgramsForOwnedWatchedChanges(
+  changedURIs []string,
+  externalURIs []string,
+  externalOwners map[string][]string,
+) {
+  if s == nil {
+    return
+  }
+  external := make(map[string]struct{}, len(externalURIs))
+  for _, uri := range externalURIs {
+    external[uri] = struct{}{}
+  }
+  ordinary := make([]string, 0, len(changedURIs))
+  for _, uri := range changedURIs {
+    if _, ok := external[uri]; !ok {
+      ordinary = append(ordinary, uri)
+    }
+  }
+  ownerTransports := make(map[string]map[string]struct{}, len(externalURIs))
+  allTransports := make(map[string]bool, len(externalURIs))
+  pluginsByKey := make(map[string]NativeLSPPluginEntry, len(s.plugins))
+  for _, plugin := range s.plugins {
+    pluginsByKey[pluginKey(plugin, s.projectContextJSON)] = plugin
+  }
+  for _, uri := range externalURIs {
+    if watchedURIHasProgramInputExtension(uri) {
+      allTransports[uri] = true
+      continue
+    }
+    owners, scoped := externalOwners[uri]
+    if !scoped || owners == nil {
+      allTransports[uri] = true
+      continue
+    }
+    transports := map[string]struct{}{}
+    for _, owner := range owners {
+      if plugin, ok := pluginsByKey[owner]; ok {
+        transports[pluginKey(plugin, s.projectContextJSON)] = struct{}{}
+      }
+    }
+    ownerTransports[uri] = transports
+  }
+  s.residentMu.Lock()
+  residents := make(map[string]*residentSidecar, len(s.residents))
+  for key, sc := range s.residents {
+    residents[key] = sc
+  }
+  s.residentMu.Unlock()
+  for key, sc := range residents {
+    changed := append([]string(nil), ordinary...)
+    selectedExternal := []string{}
+    for _, uri := range externalURIs {
+      _, owned := ownerTransports[uri][key]
+      if !allTransports[uri] && !owned {
+        continue
+      }
+      changed = append(changed, uri)
+      selectedExternal = append(selectedExternal, uri)
+    }
+    if len(changed) == 0 {
+      continue
+    }
+    sc.mu.Lock()
+    sc.changed = append(sc.changed, changed...)
+    sc.external = append(sc.external, selectedExternal...)
+    sc.mu.Unlock()
+  }
+}
+
 // shutdownResidents kills every resident child. Called on server teardown; the
 // children also exit on their own when the parent closes their stdin at process
 // exit, so this is the graceful path, not the only one.

package/internal/lspserver/lsp_plugin.go

@@ -155,6 +155,12 @@ type LSPProjectDiagnostics struct {
 type LSPDiagnosticsResult struct {
   Document []LSPDiagnostic        `json:"document"`
   Project  *LSPProjectDiagnostics `json:"project,omitempty"`
+
+  // projectUpdatedProducers names the sidecars that actually returned a
+  // project publication during this call. It is deliberately not serialized:
+  // the proxy uses it to distinguish a current computation from last-good
+  // aggregate state retained for another producer.
+  projectUpdatedProducers map[string]struct{}
 }
 
 // PluginSource is the seam between the LSP proxy and ttsc's plugin

package/internal/lspserver/lsp_project_context_transport_identity_test.go

@@ -0,0 +1,43 @@
+package lspserver
+
+import "testing"
+
+// TestLSPProjectContextTransportIdentityTracksEffectiveArgv verifies resident
+// identity follows the actual launch arguments, not a dormant capability flag.
+func TestLSPProjectContextTransportIdentityTracksEffectiveArgv(t *testing.T) {
+  withoutContext := NativeLSPPluginEntry{
+    Binary: "ttsc-no-such-shared-sidecar",
+    Name:   "@ttsc/without-context",
+  }
+  withContext := withoutContext
+  withContext.Name = "@ttsc/with-context"
+  withContext.ProjectContextArgs = true
+
+  if pluginKey(withoutContext) != pluginKey(withContext) {
+    t.Fatal("an absent project context split identical launch transports")
+  }
+  projectContextJSON := `{"physicalProjectRoot":"/project"}`
+  if pluginKey(withoutContext, projectContextJSON) ==
+    pluginKey(withContext, projectContextJSON) {
+    t.Fatal("effective project-context argv did not distinguish transports")
+  }
+
+  source := &NativePluginSource{
+    cwd:                t.TempDir(),
+    pluginsJSON:        "[]",
+    projectContextJSON: projectContextJSON,
+  }
+  _, _, _ = source.serveRun(
+    withoutContext,
+    serveVerbDiagnostics,
+    []string{"--uri=file:///project/a.ts"},
+  )
+  _, _, _ = source.serveRun(
+    withContext,
+    serveVerbDiagnostics,
+    []string{"--uri=file:///project/a.ts"},
+  )
+  if len(source.residents) != 2 {
+    t.Fatalf("differing launch argv shared %d resident sessions", len(source.residents))
+  }
+}