ttsc 0.31.5 → 0.32.0

package/cmd/ttsc/compiler_argument_cwd_test.go

@@ -1,11 +1,11 @@
 package main
 
 import (
-	"path/filepath"
-	"reflect"
-	"testing"
+  "path/filepath"
+  "reflect"
+  "testing"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 // TestCompilerArgumentCwdPreparation verifies decoded argv origin at all
@@ -20,38 +20,38 @@ import (
 // @evidence contracts/testing.md#distinguishing-cases All three frontdoors cover inherited, explicit nonempty, explicit [] and absent payload, keeping explicit empty distinct from nil inherited argv.
 // @evidence contracts/testing.md#execution-ownership Pure command preparation executes in this Go unit process with temporary cwd and t.Setenv restoration, without Program acquisition, native host launch or installation.
 func TestCompilerArgumentCwdPreparation(t *testing.T) {
-	root := t.TempDir()
-	a := filepath.Join(root, "A")
-	t.Setenv(driver.TsgoArgsCwdEnv, a)
-	for _, c := range []struct {
-		name, inherited, explicit, cwd string
-		argv                           []string
-	}{
-		{"inherited", `["--strict"]`, "", "", nil},
-		{"explicit", `["--strict"]`, `["--target","es2022"]`, "", []string{"--target", "es2022"}},
-		{"explicit empty", `["--strict"]`, `[]`, "", []string{}},
-		{"absent payload", "", "", "", nil},
-	} {
-		t.Run(c.name, func(t *testing.T) {
-			t.Setenv(driver.TsgoArgsEnv, c.inherited)
-			args := []string{"--cwd", root}
-			if c.explicit != "" {
-				args = append(args, "--tsgo-args", c.explicit)
-			}
-			build, buildStatus := prepareBuildInvocation(args)
-			compile, compileStatus := prepareAPICompileInvocation(args)
-			transform, transformStatus := prepareAPITransformInvocation(args)
-			if buildStatus != 0 || compileStatus != 0 || transformStatus != 0 {
-				t.Fatalf("preparation statuses: %d/%d/%d", buildStatus, compileStatus, transformStatus)
-			}
-			if build.options.ForceEmit || build.options.ForceNoEmit || !compile.options.ForceEmit || compile.options.ForceNoEmit || transform.options.ForceEmit || !transform.options.ForceNoEmit {
-				t.Fatal("command preparation changed its original emit policy")
-			}
-			for _, options := range []driver.LoadProgramOptions{build.options, compile.options, transform.options} {
-				if options.TsgoArgsCwd != c.cwd || !reflect.DeepEqual(options.TsgoArgs, c.argv) {
-					t.Fatalf("wrong origin: %#v", options)
-				}
-			}
-		})
-	}
+  root := t.TempDir()
+  a := filepath.Join(root, "A")
+  t.Setenv(driver.TsgoArgsCwdEnv, a)
+  for _, c := range []struct {
+    name, inherited, explicit, cwd string
+    argv                           []string
+  }{
+    {"inherited", `["--strict"]`, "", "", nil},
+    {"explicit", `["--strict"]`, `["--target","es2022"]`, "", []string{"--target", "es2022"}},
+    {"explicit empty", `["--strict"]`, `[]`, "", []string{}},
+    {"absent payload", "", "", "", nil},
+  } {
+    t.Run(c.name, func(t *testing.T) {
+      t.Setenv(driver.TsgoArgsEnv, c.inherited)
+      args := []string{"--cwd", root}
+      if c.explicit != "" {
+        args = append(args, "--tsgo-args", c.explicit)
+      }
+      build, buildStatus := prepareBuildInvocation(args)
+      compile, compileStatus := prepareAPICompileInvocation(args)
+      transform, transformStatus := prepareAPITransformInvocation(args)
+      if buildStatus != 0 || compileStatus != 0 || transformStatus != 0 {
+        t.Fatalf("preparation statuses: %d/%d/%d", buildStatus, compileStatus, transformStatus)
+      }
+      if build.options.ForceEmit || build.options.ForceNoEmit || !compile.options.ForceEmit || compile.options.ForceNoEmit || transform.options.ForceEmit || !transform.options.ForceNoEmit {
+        t.Fatal("command preparation changed its original emit policy")
+      }
+      for _, options := range []driver.LoadProgramOptions{build.options, compile.options, transform.options} {
+        if options.TsgoArgsCwd != c.cwd || !reflect.DeepEqual(options.TsgoArgs, c.argv) {
+          t.Fatalf("wrong origin: %#v", options)
+        }
+      }
+    })
+  }
 }

package/cmd/ttscserver/main.go

@@ -27,7 +27,6 @@ import (
   "syscall"
   "time"
 
-  "github.com/samchon/ttsc/packages/ttsc/internal/graphsymbols"
   "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
@@ -109,8 +108,8 @@ type lspLaunchOptions struct {
   PluginsFile                    string        `json:"-"`
   ProgressDelay                  time.Duration `json:"-"`
   SuppressExecuteCommandProvider bool          `json:"-"`
-  SuppressedExecuteCommandIDs     string        `json:"-"`
-  ExecuteCommandIDPrefix          string        `json:"-"`
+  SuppressedExecuteCommandIDs    string        `json:"-"`
+  ExecuteCommandIDPrefix         string        `json:"-"`
 }
 
 // resolveLaunch is a private launcher/native protocol. It uses the same parser
@@ -227,14 +226,6 @@ func startLSP(options *lspLaunchOptions) int {
     return 2
   }
 
-  // The SymbolProvider answers textDocument/documentSymbol and
-  // textDocument/references from ttsc's compiler-backed code graph. tsgo
-  // implements both methods itself, so the proxy forwards to tsgo whenever it
-  // advertises the capability and consults this provider only as a fallback
-  // (tsgo did not advertise). It loads the program lazily on the first such
-  // request, so wiring it here adds no startup cost.
-  symbolProvider := graphsymbols.NewProvider(options.Cwd, options.Tsconfig)
-
   err = runLSPServer(ctx, lspserver.LSPServerOptions{
     In:                             stdin,
     Out:                            stdout,
@@ -242,7 +233,6 @@ func startLSP(options *lspLaunchOptions) int {
     Cwd:                            options.Cwd,
     TsgoBinary:                     options.TsgoBinary,
     Source:                         source,
-    SymbolProvider:                 symbolProvider,
     SuppressExecuteCommandProvider: options.SuppressExecuteCommandProvider,
     SuppressedExecuteCommandIDs:    splitCSV(options.SuppressedExecuteCommandIDs),
     ExecuteCommandIDPrefix:         options.ExecuteCommandIDPrefix,

package/cmd/ttscserver/resolve_launch_uses_native_flag_authority_test.go

@@ -46,12 +46,12 @@ func TestResolveLaunchUsesNativeFlagAuthority(t *testing.T) {
   defer func() { getwd, runLSPServer, notifyContext = previousGetwd, previousHost, previousNotify }()
 
   for _, test := range []struct {
-    name string
-    args []string
-    cwd string
-    config string
+    name     string
+    args     []string
+    cwd      string
+    config   string
     explicit bool
-    tsgo string
+    tsgo     string
   }{
     {"last assignments", []string{"--stdio", "--cwd", "/a", "-cwd=/b", "--tsconfig=first.json", "-tsconfig", "last.json", "--tsgo=/first", "-tsgo", "/last"}, "/b", "last.json", true, "/last"},
     {"equal duplicates", []string{"-stdio", "-cwd=/b", "--cwd", "/b", "-tsconfig=last.json", "--tsconfig=last.json"}, "/b", "last.json", true, "/environment-tsgo"},
@@ -107,8 +107,8 @@ func TestResolveLaunchUsesNativeFlagAuthority(t *testing.T) {
   }
 
   for _, test := range []struct {
-    name string
-    args []string
+    name       string
+    args       []string
     diagnostic string
   }{
     {"unknown", []string{"--stdio", "--cwd=/missing", "--unknown"}, "flag provided but not defined: -unknown"},

package/driver/lsp.go

@@ -201,58 +201,19 @@ type LSPCompletionHint = lspserver.LSPCompletionHint
 // @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type LSPCompletionItem = lspserver.LSPCompletionItem
 
-// LSPSymbolKind carries LSP symbol classification values for editor outlines.
-//
-// @evidence contracts/common.md#principled-implementation The alias retains the server's protocol numeric classifications unchanged.
-// @evidence contracts/common.md#clear-and-simple-design Outline classification remains one enum shared by provider and proxy.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts Protocol values are forwarded without source-name or consumer special cases.
-// @evidence contracts/common.md#meaningful-documentation The enum's outline purpose is stated directly under documentation-skill guidance.
-// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
-// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
-// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
-// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
-type LSPSymbolKind = lspserver.LSPSymbolKind
-
-// LSPDocumentSymbol forms an outline hierarchy; SelectionRange locates the name
-// within the declaration's Range and Children hold nested members.
-//
-// @evidence contracts/common.md#principled-implementation Alias identity keeps hierarchical symbols and their two range roles intact.
-// @evidence contracts/common.md#clear-and-simple-design The provider and proxy share one nested outline representation.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts No flattening adapter or guessed member relationship is introduced.
-// @evidence contracts/common.md#meaningful-documentation Native prose explains hierarchy and range roles following the documentation skill.
-// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
-// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
-// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
-// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
-type LSPDocumentSymbol = lspserver.LSPDocumentSymbol
-
-// LSPLocation identifies a reference range inside the document named by its URI.
+// LSPLocation identifies a range inside the document named by its URI. Plugin
+// diagnostics carry one per related-information site.
 //
 // @evidence contracts/common.md#principled-implementation The alias preserves the server's URI and LSP coordinate pair.
-// @evidence contracts/common.md#clear-and-simple-design References use the existing location schema instead of a filesystem-path adapter.
+// @evidence contracts/common.md#clear-and-simple-design Related diagnostic information uses the existing location schema instead of a filesystem-path adapter.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts No OS path spelling is substituted for a protocol document URI.
-// @evidence contracts/common.md#meaningful-documentation Native prose distinguishes document identity and range using documentation-skill guidance.
+// @evidence contracts/common.md#meaningful-documentation Native prose distinguishes document identity and range and names the related-information use, following documentation-skill guidance.
 // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
 // @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
 // @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type LSPLocation = lspserver.LSPLocation
 
-// SymbolProvider is the driver-level alias for lspserver.SymbolProvider.
-// It is the seam that answers textDocument/documentSymbol and
-// textDocument/references from ttsc's compiler-backed code graph when upstream
-// tsgo does not advertise them, or when the caller selects local graph answers.
-//
-// @evidence contracts/common.md#principled-implementation The server interface alias preserves the method set required by local symbol routing.
-// @evidence contracts/common.md#clear-and-simple-design Driver embedders implement the existing provider seam without another proxy layer.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts The public extension does not replace upstream methods or patch compiler internals.
-// @evidence contracts/common.md#meaningful-documentation Native prose names the two routed requests and owning graph under documentation-skill guidance.
-// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
-// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
-// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
-// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
-type SymbolProvider = lspserver.SymbolProvider
-
 // PluginSource is the driver-level alias for lspserver.PluginSource.
 // It is the public seam downstream pipelines implement to contribute
 // diagnostics, code actions, and workspace commands to the LSP proxy.

package/driver/rewrite.go

@@ -452,7 +452,7 @@ func collectEmittedRewriteCalls(file *ast.SourceFile) []emittedRewriteCall {
       if call.QuestionDotToken == nil {
         if path := rewriteCallPath(call.Expression); path != "" {
           calls = append(calls, emittedRewriteCall{
-            start: shimscanner.GetTokenPosOfNode(node, file, false),
+            start:     shimscanner.GetTokenPosOfNode(node, file, false),
             calleeEnd: call.Expression.End(), end: node.End(), path: path,
           })
         }

package/internal/e2etrace/completion_hints.go

@@ -23,10 +23,10 @@ func CompletionHintsPublication(cwd, producer string, generation uint64, outcome
     return
   }
   data := map[string]any{
-    "producer": producer,
+    "producer":   producer,
     "generation": generation,
-    "outcome": outcome,
-    "hints": hints,
+    "outcome":    outcome,
+    "hints":      hints,
   }
   if err != nil {
     data["error"] = err.Error()

package/internal/e2etrace/completion_hints_test.go

@@ -31,8 +31,8 @@ func TestCompletionHintsPublicationPreservesTerminalOutcomes(t *testing.T) {
   t.Setenv("TTSC_E2E_TRACE", root)
   for _, entry := range []struct {
     outcome string
-    hints int
-    err error
+    hints   int
+    err     error
   }{
     {"published", 0, nil},
     {"published", 2, nil},
@@ -47,22 +47,32 @@ func TestCompletionHintsPublicationPreservesTerminalOutcomes(t *testing.T) {
     t.Fatalf("observer sink: %v %v", entries, err)
   }
   body, err := os.ReadFile(filepath.Join(root, entries[0].Name()))
-  if err != nil { t.Fatal(err) }
+  if err != nil {
+    t.Fatal(err)
+  }
   lines := strings.Split(strings.TrimSuffix(string(body), "\n"), "\n")
-  expected := []struct{ outcome string; hints float64; err string }{
+  expected := []struct {
+    outcome string
+    hints   float64
+    err     string
+  }{
     {"published", 0, ""}, {"published", 2, ""},
     {"run-failed", 0, "native failed"}, {"decode-failed", 0, "invalid JSON"},
     {"superseded", 2, ""},
   }
-  if len(lines) != len(expected) { t.Fatalf("got %d terminal records", len(lines)) }
+  if len(lines) != len(expected) {
+    t.Fatalf("got %d terminal records", len(lines))
+  }
   for index, line := range lines {
     var record struct {
-      Schema int `json:"schema"`
-      Event string `json:"event"`
-      Cwd string `json:"cwd"`
-      Data map[string]any `json:"data"`
+      Schema int            `json:"schema"`
+      Event  string         `json:"event"`
+      Cwd    string         `json:"cwd"`
+      Data   map[string]any `json:"data"`
+    }
+    if err := json.Unmarshal([]byte(line), &record); err != nil {
+      t.Fatal(err)
     }
-    if err := json.Unmarshal([]byte(line), &record); err != nil { t.Fatal(err) }
     want := expected[index]
     if record.Schema != 1 || record.Event != "lsp-hints-publication" || record.Cwd != "project" ||
       record.Data["producer"] != "producer" || record.Data["generation"] != float64(7) ||
@@ -70,7 +80,11 @@ func TestCompletionHintsPublicationPreservesTerminalOutcomes(t *testing.T) {
       t.Errorf("terminal %d: %s", index, line)
     }
     if want.err == "" {
-      if _, exists := record.Data["error"]; exists { t.Errorf("unexpected terminal error: %s", line) }
-    } else if record.Data["error"] != want.err { t.Errorf("terminal error: %s", line) }
+      if _, exists := record.Data["error"]; exists {
+        t.Errorf("unexpected terminal error: %s", line)
+      }
+    } else if record.Data["error"] != want.err {
+      t.Errorf("terminal error: %s", line)
+    }
   }
 }

package/internal/graph/build.go

@@ -93,12 +93,11 @@ func BuildFiles(prog *driver.Program, selected []string, baseNodes map[string]*N
 // the compiler AST or into the preceding generation's nodes: resolved is keyed
 // by *shimast.Node, docHosts holds one per documented declaration, and baseNodes
 // is the whole prior endpoint index. A consumer that retains the returned Graph
-// would otherwise pin all of it for as long as it held the graph —
-// internal/graphsymbols retains one for the lifetime of an editor session
-// between invalidations, closing the Program while the maps that reference its
-// AST live on. Clearing them here rather than at that consumer keeps the
-// decision with the producer, which is the only side that knows which fields are
-// scratch.
+// would otherwise pin all of it for as long as it held the graph: the resident
+// serve session in cmd/ttscgraph holds a prepared projection until it publishes,
+// and its compiler session can replace and close the Program in the meantime.
+// Clearing them here rather than at that consumer keeps the decision with the
+// producer, which is the only side that knows which fields are scratch.
 //
 // ExportedTargets and ImplementationSources are deliberately not cleared: the
 // shard expansion path in cmd/ttscgraph/serve_shards.go reads both after this

package/internal/graph/graph.go

@@ -490,9 +490,9 @@ func nodeFile(id string) string {
   return parts.path
 }
 
-// NodeFile is the graph-symbol provider's shared view of the node-id grammar.
-// Keeping the parser here prevents its LSP path comparison from drifting from
-// the dump producer's edge-evidence lookup.
+// NodeFile is the resident shard producer's shared view of the node-id grammar.
+// Keeping the parser here prevents its per-file shard ownership from drifting
+// from the dump producer's edge-evidence lookup.
 //
 // @evidence contracts/common.md#principled-implementation The shared parser requires an unescaped separator and nonempty name/kind suffix, then decodes the reported path. It does not validate the kind vocabulary, path existence or producer authenticity.
 // @evidence contracts/common.md#clear-and-simple-design One public adapter exposes the same parser used by dump evidence and native graph consumers.

package/internal/graph/line_model.go

@@ -8,9 +8,8 @@ import (
 )
 
 // ECMALineStarts returns the byte offset of each logical source line. The
-// compiler is the authority for which bytes end a line, so graph evidence and
-// graph-backed LSP locations cannot drift from its LF, CRLF, CR, LS, and PS
-// coordinates.
+// compiler is the authority for which bytes end a line, so graph evidence
+// cannot drift from its LF, CRLF, CR, LS, and PS coordinates.
 //
 // @evidence contracts/common.md#principled-implementation Compiler-produced ECMA line boundaries are copied into graph byte-offset coordinates without substituting a newline convention.
 // @evidence contracts/common.md#clear-and-simple-design This adapter centralizes the compiler-to-graph integer representation so consumers share the same line model.
@@ -29,38 +28,6 @@ func ECMALineStarts(text string) []int {
   return starts
 }
 
-// LineEnd returns the byte offset immediately before line's terminator, or the
-// end of text for its final logical line. starts must come from ECMALineStarts
-// for the same text.
-//
-// @evidence contracts/common.md#principled-implementation The supplied index bounds one logical line and ECMA terminator widths identify its exclusive content end.
-// @evidence contracts/common.md#clear-and-simple-design One bounded scan handles all compiler terminators without allocating a substring or rebuilding the line index.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts Invalid line indices return the documented text boundary rather than manufacturing fixture-specific spans.
-// @evidence contracts/common.md#meaningful-documentation The native comment identifies byte units, final-line behavior and the same-text index precondition under the documentation skill.
-// @evidence contracts/performance.md#efficient-algorithms Index lookup is constant time and scanning costs only the selected line's byte length, with constant temporary space.
-// @evidenceExclude contracts/performance.md#reuse-equivalent-work This calculation consumes a caller-owned reusable line index and creates no cross-request computation owner.
-// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No retained state or native resource is acquired.
-// @evidenceExclude contracts/portability.md#os-neutral-implementation LineEnd computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
-func LineEnd(text string, starts []int, line int) int {
-  if line < 0 || line >= len(starts) {
-    return len(text)
-  }
-  if line+1 == len(starts) {
-    return len(text)
-  }
-  for i := starts[line]; i < starts[line+1]; {
-    if lineTerminatorWidth(text, i) > 0 {
-      return i
-    }
-    _, size := utf8.DecodeRuneInString(text[i:])
-    if size == 0 {
-      return len(text)
-    }
-    i += size
-  }
-  return starts[line+1]
-}
-
 // FirstCodeOffset advances over leading whitespace and comments so a graph
 // span begins at its declaration rather than its leading trivia.
 //

package/internal/lspserver/lsp_clean_didopen_refreshes_compiler_state_test.go

@@ -35,21 +35,6 @@ func (s *recordingResidentSource) recorded() [][]string {
   return append([][]string(nil), s.calls...)
 }
 
-// recordingSymbolProvider counts Invalidate calls; the two answer methods are
-// never reached by these notification tests. Invalidate is only ever called from
-// the notification path, which is the test's own goroutine.
-type recordingSymbolProvider struct{ invalidations int }
-
-func (p *recordingSymbolProvider) DocumentSymbols(string) ([]LSPDocumentSymbol, error) {
-  return nil, nil
-}
-
-func (p *recordingSymbolProvider) References(string, LSPPosition, bool) ([]LSPLocation, error) {
-  return nil, nil
-}
-
-func (p *recordingSymbolProvider) Invalidate() { p.invalidations++ }
-
 // testFileURI renders an absolute path as the file URI an editor would send.
 func testFileURI(path string) string {
   return "file:///" + strings.TrimPrefix(filepath.ToSlash(path), "/")
@@ -68,24 +53,24 @@ func didOpenEnvelope(uri string, text string) Envelope {
 }
 
 // TestLSPCleanDidOpenRefreshesCompilerState checks invalidation dispatch on
-// directly supplied clean and dirty didOpen envelopes. The resident source and
-// symbol provider are recording instances, not actual compiler-backed caches.
+// directly supplied clean and dirty didOpen envelopes. The resident source is a
+// recording instance, not an actual compiler-backed cache.
 //
-// Matching disk should dispatch one invalidation to each recording instance and
-// name the clean URI; a dirty second file should not increase either count.
+// Matching disk should dispatch one resident invalidation naming the clean URI;
+// a dirty second file should not add another.
 // Returning handled=false establishes eligibility for forwarding, not an actual
 // upstream frame. Program freshness and published diagnostic content are not
 // observed, and the scheduled NullPluginSource diagnostics are not joined here.
 //
-//  1. Write a file, open it with the same text, and assert both caches were
-//     refreshed and the resident refresh named that document's URI.
+//  1. Write a file, open it with the same text, and assert the resident Program
+//     was refreshed for exactly that document's URI.
 //  2. Open a second file with text that differs from disk.
-//  3. Assert neither recorder gained a call and the notification is not handled.
+//  3. Assert the recorder gained no call and the notification is not handled.
 //
-// @evidence contracts/testing.md#behavioral-verification A clean direct didOpen produces one recorded symbol invalidation and one resident invalidation naming its URI; a dirty second open preserves both counts. Both return handled=false. Actual compiler cache refresh, diagnostic content, upstream forwarding, and asynchronous completion are not asserted.
-// @evidence contracts/testing.md#independent-expectations The refresh counts and the named URI are literal expectations for the two opened files.
+// @evidence contracts/testing.md#behavioral-verification A clean direct didOpen produces one resident invalidation naming its URI; a dirty second open adds none. Both return handled=false. Actual compiler cache refresh, diagnostic content, upstream forwarding, and asynchronous completion are not asserted.
+// @evidence contracts/testing.md#independent-expectations The refresh count and the named URI are literal expectations for the two opened files.
 // @evidence contracts/testing.md#distinguishing-cases Two owned files have the same disk bytes, but the clean buffer matches and the dirty buffer differs. They also have different URIs and run sequentially on one proxy; this is not a one-variable-only or reversed-order experiment.
-// @evidence contracts/testing.md#execution-ownership Owns two temporary native files and a NewProxy with supported instance-owned recording PluginSource/SymbolProvider and io.Discard streams. Direct handleEditorEnvelope reads buffer/disk state and schedules NullPluginSource diagnostics on the clean branch; no join or diagnostics-result oracle is claimed. No actual compiler Program, sidecar, product CLI, installed consumer, or upstream server runs.
+// @evidence contracts/testing.md#execution-ownership Owns two temporary native files and a NewProxy with supported instance-owned recording PluginSource and io.Discard streams. Direct handleEditorEnvelope reads buffer/disk state and schedules NullPluginSource diagnostics on the clean branch; no join or diagnostics-result oracle is claimed. No actual compiler Program, sidecar, product CLI, installed consumer, or upstream server runs.
 func TestLSPCleanDidOpenRefreshesCompilerState(t *testing.T) {
   dir := t.TempDir()
   clean := filepath.Join(dir, "clean.ts")
@@ -95,12 +80,10 @@ func TestLSPCleanDidOpenRefreshesCompilerState(t *testing.T) {
   cleanURI := testFileURI(clean)
 
   plugins := &recordingResidentSource{}
-  symbols := &recordingSymbolProvider{}
   proxy := NewProxy(ProxyOptions{
-    EditorOut:      io.Discard,
-    UpstreamIn:     io.Discard,
-    Source:         plugins,
-    SymbolProvider: symbols,
+    EditorOut:  io.Discard,
+    UpstreamIn: io.Discard,
+    Source:     plugins,
   })
 
   handled, err := proxy.handleEditorEnvelope(
@@ -113,9 +96,6 @@ func TestLSPCleanDidOpenRefreshesCompilerState(t *testing.T) {
   if handled {
     t.Fatal("clean didOpen was answered locally instead of forwarded to tsgo")
   }
-  if symbols.invalidations != 1 {
-    t.Errorf("clean didOpen symbol invalidations = %d, want 1", symbols.invalidations)
-  }
   if len(plugins.recorded()) != 1 {
     t.Fatalf("clean didOpen resident invalidations = %d, want 1", len(plugins.recorded()))
   }
@@ -137,9 +117,6 @@ func TestLSPCleanDidOpenRefreshesCompilerState(t *testing.T) {
   if handled {
     t.Fatal("dirty didOpen was answered locally instead of forwarded to tsgo")
   }
-  if symbols.invalidations != 1 {
-    t.Errorf("dirty didOpen refreshed the symbol provider: invalidations = %d, want 1", symbols.invalidations)
-  }
   if len(plugins.recorded()) != 1 {
     t.Errorf("dirty didOpen refreshed the resident daemon: calls = %v, want only the clean open's", plugins.recorded())
   }

package/internal/lspserver/lsp_hints_refresh_ignores_a_superseded_generation_test.go

@@ -22,10 +22,14 @@ func TestLSPHintsRefreshIgnoresASupersededGeneration(t *testing.T) {
 
   if !source.storeCompletionHints(plugin, 2, []LSPCompletionHint{
     {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "returns"}}},
-  }) { t.Error("newer corpus was not accepted") }
+  }) {
+    t.Error("newer corpus was not accepted")
+  }
   if source.storeCompletionHints(plugin, 1, []LSPCompletionHint{
     {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "stale"}}},
-  }) { t.Error("stale corpus claimed publication") }
+  }) {
+    t.Error("stale corpus claimed publication")
+  }
 
   hints := source.CompletionHints()
   if len(hints) != 1 || len(hints[0].Items) != 1 || hints[0].Items[0].Insert != "returns" {
@@ -34,7 +38,9 @@ func TestLSPHintsRefreshIgnoresASupersededGeneration(t *testing.T) {
 
   if !source.storeCompletionHints(plugin, 3, []LSPCompletionHint{
     {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "param"}}},
-  }) { t.Error("new generation was not accepted") }
+  }) {
+    t.Error("new generation was not accepted")
+  }
   hints = source.CompletionHints()
   if len(hints) != 1 || hints[0].Items[0].Insert != "param" {
     t.Fatalf("the guard rejected a newer generation as well: %#v", hints)

package/internal/lspserver/lsp_plugin.go

@@ -120,6 +120,25 @@ type LSPDiagnostic struct {
   Message string `json:"message"`
 }
 
+// LSPLocation is the wire shape of an LSP Location: a range inside the document
+// its URI names. Diagnostic related information carries one per secondary site.
+//
+// @evidence contracts/common.md#principled-implementation URI plus range identifies a site independently of the document currently open in the editor.
+// @evidence contracts/common.md#clear-and-simple-design Related diagnostic information shares this one location value.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Locations are producer values rather than guessed local filenames.
+// @evidence contracts/common.md#meaningful-documentation Native prose names the protocol shape and the related-information use, following the documentation skill.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+type LSPLocation struct {
+  // URI identifies the target document using protocol spelling.
+  URI string `json:"uri"`
+
+  // Range locates the site in that document's session UTF-16 coordinates.
+  Range LSPRange `json:"range"`
+}
+
 // LSPDiagnosticRelatedInformation is one entry of a diagnostic's
 // relatedInformation: a secondary location with a message. It reuses the
 // package's LSPLocation (a URI plus a range). The proxy does not read it — it