ttsc 0.23.0 → 0.24.0

package/cmd/ttscgraph/serve.go

@@ -13,6 +13,7 @@ import (
   "slices"
   "sort"
   "strings"
+  "time"
 
   shimtsoptions "github.com/microsoft/typescript-go/shim/tsoptions"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
@@ -45,7 +46,9 @@ const (
   serveModeUnchanged = "unchanged"
   // serveModeIncremental is edits applied onto the reused resident program.
   serveModeIncremental = "incremental"
-  // serveModeRebuild is edits applied but the program could not be reused.
+  // serveModeRebuild is edits applied but graph projection requires a complete
+  // rebuild, either because the program could not be reused or because a
+  // declaration-file boundary has no authored source shard of its own.
   serveModeRebuild = "rebuild"
   // serveModeError is a request that produced no snapshot. It is a transport
   // mode, not a computation mode: it exists so mode is never absent, because a
@@ -71,10 +74,15 @@ var serveCapabilities = fullSnapshotCapabilities
 
 type serveRequest struct {
   ID int `json:"id"`
+  // GraphSnapshotVersion opts into the incremental shard protocol. Omitted
+  // requests retain the schema-v6 full-dump response for existing
+  // @ttsc/graph clients.
+  GraphSnapshotVersion int `json:"graphSnapshotVersion,omitempty"`
 }
 
 type serveResponse struct {
-  Dump *graph.Dump `json:"dump,omitempty"`
+  Dump     *graph.Dump         `json:"dump,omitempty"`
+  Snapshot *serveGraphSnapshot `json:"snapshot,omitempty"`
   // Error is set when the request produced no snapshot; Mode is then
   // serveModeError.
   Error string `json:"error,omitempty"`
@@ -90,6 +98,8 @@ type serveResponse struct {
   Changed      bool     `json:"changed"`
 }
 
+const graphPhaseTraceEnvironment = "SAMCHON_GRAPH_TTSC_PHASE_TRACE"
+
 // newServeResponse stamps the fields every response owes the client, so no exit
 // from the serve loop can forget one.
 func newServeResponse(id int) serveResponse {
@@ -124,13 +134,17 @@ type graphSession struct {
   // generation, captured from the same parse that produced configHashes and
   // rootFiles so the published evidence and the invalidation state can never
   // describe different loads.
-  configDigests []graph.FileDigest
-  roots         []graph.RootFile
-  initialized   bool
-  // pendingDumpMode remembers a generation whose state was captured but whose
-  // dump failed. Until an input change lets the session rebuild, an unchanged
-  // request must retry that dump instead of falsely confirming the older graph.
-  pendingDumpMode string
+  configDigests           []graph.FileDigest
+  roots                   []graph.RootFile
+  initialized             bool
+  graphStore              *serveGraphStore
+  requestProtocol         int
+  requestProtocolSelected bool
+  // pending remembers a generation whose state was captured but whose selected
+  // projection failed. Until an input change lets the session rebuild, an
+  // unchanged request retries the same full or partial invalidation instead of
+  // falsely confirming the older client graph.
+  pending *graphChange
 }
 
 func newGraphSession(cwd, tsconfig string) (*graphSession, error) {
@@ -149,106 +163,187 @@ func (s *graphSession) Close() error {
 }
 
 func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
+  change, err := s.nextChange(false)
+  if err != nil {
+    return nil, "", false, err
+  }
+  if change == nil {
+    return nil, serveModeUnchanged, false, nil
+  }
+  dump, err := s.buildDump()
+  if err != nil {
+    s.pending = change
+    return nil, "", false, err
+  }
+  s.pending = nil
+  return &dump, change.mode, true, nil
+}
+
+type graphChange struct {
+  mode        string
+  files       []string
+  publicFiles []string
+  full        bool
+}
+
+// nextChange advances only the resident compiler and its captured input state.
+// Projection is deliberately outside this method so the legacy full-dump and
+// incremental shard protocols share exactly one invalidation decision without
+// forcing either representation onto the other.
+func (s *graphSession) nextChange(trackPublicShape bool) (*graphChange, error) {
   if !s.initialized {
     // The captured compiler state is initialized even when its first dump is
     // not publishable. Mark the attempt before building so a later request can
     // observe a config/source edit that repairs the path error instead of
     // retrying the stale Program forever.
     s.initialized = true
-    dump, err := s.buildDump()
-    if err != nil {
-      s.pendingDumpMode = serveModeInitial
-      return nil, "", false, err
-    }
-    s.pendingDumpMode = ""
-    return &dump, serveModeInitial, true, nil
+    return &graphChange{mode: serveModeInitial, full: true}, nil
   }
 
   configChanged, err := hashesChanged(s.configHashes)
   if err != nil {
-    return nil, "", false, err
+    return nil, err
   }
   if configChanged {
     if err := s.reload(); err != nil {
-      return nil, "", false, err
+      return nil, err
     }
-    return s.changedSnapshot(serveModeReload)
+    return &graphChange{mode: serveModeReload, full: true}, nil
   }
 
   if diskStatesChanged(s.auxStates) {
     if err := s.reload(); err != nil {
-      return nil, "", false, err
+      return nil, err
     }
-    return s.changedSnapshot(serveModeReload)
+    return &graphChange{mode: serveModeReload, full: true}, nil
   }
 
   roots, err := projectRootFiles(s.compiler.Program(), true)
   if err != nil {
-    return nil, "", false, err
+    return nil, err
   }
   if !slices.Equal(s.rootFiles, roots) {
     if err := s.reload(); err != nil {
-      return nil, "", false, err
+      return nil, err
     }
-    return s.changedSnapshot(serveModeReload)
+    return &graphChange{mode: serveModeReload, full: true}, nil
   }
 
   changed, deleted, err := changedSources(s.sourceHashes)
   if err != nil {
-    return nil, "", false, err
+    return nil, err
   }
   if deleted {
     if err := s.reload(); err != nil {
-      return nil, "", false, err
+      return nil, err
     }
-    return s.changedSnapshot(serveModeReload)
+    return &graphChange{mode: serveModeReload, full: true}, nil
   }
   if len(changed) == 0 {
-    if s.pendingDumpMode != "" {
-      return s.changedSnapshot(s.pendingDumpMode)
+    if s.pending != nil {
+      return s.pending, nil
     }
-    return nil, serveModeUnchanged, false, nil
+    return nil, nil
   }
   if s.compiler.Program().HasLinkedProgramPlugins() {
     if err := s.reload(); err != nil {
-      return nil, "", false, err
+      return nil, err
     }
-    return s.changedSnapshot(serveModeReload)
+    return &graphChange{mode: serveModeReload, full: true}, nil
   }
 
   mode := serveModeIncremental
+  full := false
   paths := make([]string, 0, len(changed))
   for path := range changed {
     paths = append(paths, path)
   }
   sort.Strings(paths)
+  oldShapes := make(map[string]string, len(paths))
+  for _, path := range paths {
+    source := s.compiler.Program().SourceFile(path)
+    if source == nil {
+      if err := s.reload(); err != nil {
+        return nil, err
+      }
+      return &graphChange{mode: serveModeReload, full: true}, nil
+    }
+    if source.IsDeclarationFile {
+      mode = serveModeRebuild
+      full = true
+      continue
+    }
+    if trackPublicShape {
+      shape, err := s.compiler.Program().DeclarationShapeDigest(source)
+      if err != nil {
+        return nil, err
+      }
+      oldShapes[path] = shape
+    }
+  }
   for _, path := range paths {
     if reused := s.compiler.Apply(path, changed[path]); !reused {
       mode = serveModeRebuild
+      full = true
     }
     current, exists := s.compiler.SourceText(path)
     expected := driver.ApplySourcePreambleToFile(path, changed[path], s.compiler.Program().SourcePreamble)
     if !exists || current != expected {
       if err := s.reload(); err != nil {
-        return nil, "", false, err
+        return nil, err
       }
-      return s.changedSnapshot(serveModeReload)
+      return &graphChange{mode: serveModeReload, full: true}, nil
+    }
+    source := s.compiler.Program().SourceFile(path)
+    if source == nil {
+      if err := s.reload(); err != nil {
+        return nil, err
+      }
+      return &graphChange{mode: serveModeReload, full: true}, nil
+    }
+    if source.IsDeclarationFile {
+      mode = serveModeRebuild
+      full = true
     }
   }
   if err := s.captureState(); err != nil {
-    return nil, "", false, err
+    // The compiler already accepted the edit. Preserve a full retry marker so
+    // a transient hashing/input failure cannot make the next request compare
+    // public shape against the uncommitted compiler generation and publish an
+    // incomplete closure.
+    s.pending = &graphChange{mode: serveModeRebuild, full: true}
+    return nil, err
   }
-  return s.changedSnapshot(mode)
-}
-
-func (s *graphSession) changedSnapshot(mode string) (*graph.Dump, string, bool, error) {
-  dump, err := s.buildDump()
-  if err != nil {
-    s.pendingDumpMode = mode
-    return nil, "", false, err
+  publicFiles := []string{}
+  if trackPublicShape && !full {
+    for _, path := range paths {
+      source := s.compiler.Program().SourceFile(path)
+      if source == nil {
+        return &graphChange{mode: serveModeRebuild, full: true}, nil
+      }
+      shape, err := s.compiler.Program().DeclarationShapeDigest(source)
+      if err != nil {
+        mode = serveModeRebuild
+        full = true
+        publicFiles = nil
+        break
+      }
+      if shape != oldShapes[path] {
+        publicFiles = append(publicFiles, path)
+      }
+    }
+  }
+  if s.pending != nil {
+    if s.pending.full {
+      mode = s.pending.mode
+      full = true
+      paths = nil
+    } else if !full {
+      paths = compactSortedStrings(append(paths, s.pending.files...))
+      publicFiles = compactSortedStrings(append(publicFiles, s.pending.publicFiles...))
+    }
   }
-  s.pendingDumpMode = ""
-  return &dump, mode, true, nil
+  return &graphChange{mode: mode, files: paths, publicFiles: publicFiles, full: full}, nil
 }
 
 func (s *graphSession) reload() error {
@@ -750,26 +845,86 @@ func serveSnapshots(input io.Reader, output io.Writer, cwd, tsconfig string) int
       fmt.Fprintf(stderr, "ttscgraph: unaddressable serve request: %v\n", err)
       return 1
     }
+    requestStarted := time.Now()
+    if request.GraphSnapshotVersion != 0 && request.GraphSnapshotVersion != graphSnapshotProtocolVersion {
+      if err := encodeServeResponseWithTrace(encoder, errorResponse(
+        request.ID,
+        fmt.Sprintf(
+          "ttscgraph: unsupported graph snapshot protocol v%d (supported: v%d)",
+          request.GraphSnapshotVersion,
+          graphSnapshotProtocolVersion,
+        ),
+      ), requestStarted, 0, 0, 0); err != nil {
+        fmt.Fprintf(stderr, "ttscgraph: write serve response: %v\n", err)
+        return 1
+      }
+      continue
+    }
+    var loadDuration time.Duration
     if session == nil {
+      loadStarted := time.Now()
       created, err := newGraphSession(cwd, tsconfig)
+      loadDuration = time.Since(loadStarted)
       if err != nil {
-        _ = encoder.Encode(errorResponse(request.ID, err.Error()))
+        if err := encodeServeResponseWithTrace(
+          encoder,
+          errorResponse(request.ID, err.Error()),
+          requestStarted,
+          loadDuration,
+          0,
+          0,
+        ); err != nil {
+          fmt.Fprintf(stderr, "ttscgraph: write serve response: %v\n", err)
+          return 1
+        }
         continue
       }
       session = created
     }
-    dump, mode, changed, err := session.Snapshot()
+    if session.requestProtocolSelected && session.requestProtocol != request.GraphSnapshotVersion {
+      if err := encodeServeResponseWithTrace(encoder, errorResponse(
+        request.ID,
+        "ttscgraph: graphSnapshotVersion cannot change within one resident session",
+      ), requestStarted, loadDuration, 0, 0); err != nil {
+        fmt.Fprintf(stderr, "ttscgraph: write serve response: %v\n", err)
+        return 1
+      }
+      continue
+    }
+    session.requestProtocol = request.GraphSnapshotVersion
+    session.requestProtocolSelected = true
+    var dump *graph.Dump
+    var snapshot *serveGraphSnapshot
+    var mode string
+    var changed bool
+    var semanticDuration time.Duration
+    var exportDuration time.Duration
+    var err error
+    if request.GraphSnapshotVersion == graphSnapshotProtocolVersion {
+      snapshot, mode, changed, semanticDuration, exportDuration, err = session.snapshotShardsWithTiming()
+    } else {
+      dump, mode, changed, err = session.Snapshot()
+    }
     response := newServeResponse(request.ID)
     response.Dump = dump
+    response.Snapshot = snapshot
     response.Mode = mode
     response.Changed = changed
     if err != nil {
       response.Error = err.Error()
       response.Dump = nil
+      response.Snapshot = nil
       response.Mode = serveModeError
       response.Changed = false
     }
-    if err := encoder.Encode(response); err != nil {
+    if err := encodeServeResponseWithTrace(
+      encoder,
+      response,
+      requestStarted,
+      loadDuration,
+      semanticDuration,
+      exportDuration,
+    ); err != nil {
       fmt.Fprintf(stderr, "ttscgraph: write serve response: %v\n", err)
       return 1
     }
@@ -780,3 +935,64 @@ func serveSnapshots(input io.Reader, output io.Writer, cwd, tsconfig string) int
   }
   return 0
 }
+
+// encodeServeResponseWithTrace accounts for every addressed response, including
+// failures that occur before a graph session exists.
+func encodeServeResponseWithTrace(
+  encoder *json.Encoder,
+  response serveResponse,
+  requestStarted time.Time,
+  loadDuration time.Duration,
+  semanticDuration time.Duration,
+  exportDuration time.Duration,
+) error {
+  encodeStarted := time.Now()
+  if err := encoder.Encode(response); err != nil {
+    return err
+  }
+  writeServePhaseTrace(
+    response.ID,
+    response.Mode,
+    loadDuration,
+    semanticDuration,
+    exportDuration,
+    time.Since(encodeStarted),
+    time.Since(requestStarted),
+  )
+  return nil
+}
+
+// writeServePhaseTrace emits opt-in timings without source paths or payloads.
+func writeServePhaseTrace(
+  request int,
+  mode string,
+  load time.Duration,
+  semantic time.Duration,
+  export time.Duration,
+  encode time.Duration,
+  total time.Duration,
+) {
+  if os.Getenv(graphPhaseTraceEnvironment) != "1" {
+    return
+  }
+  phases := []struct {
+    name     string
+    duration time.Duration
+  }{
+    {name: "native-load", duration: load},
+    {name: "semantic-refresh", duration: semantic},
+    {name: "shard-export", duration: export},
+    {name: "encode", duration: encode},
+    {name: "producer-total", duration: total},
+  }
+  for _, phase := range phases {
+    fmt.Fprintf(
+      stderr,
+      "@samchon/graph: ttscgraph-phase owner=producer request=%d mode=%s phase=%s durationMs=%.3f\n",
+      request,
+      mode,
+      phase.name,
+      float64(phase.duration)/float64(time.Millisecond),
+    )
+  }
+}

package/cmd/ttscgraph/serve_early_error_encode_failure_is_observable_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+  "bytes"
+  "errors"
+  "strings"
+  "testing"
+)
+
+type rejectedServeWriter struct{}
+
+func (rejectedServeWriter) Write([]byte) (int, error) {
+  return 0, errors.New("synthetic response write failure")
+}
+
+// TestServeEarlyErrorEncodeFailureIsObservable proves a rejected early error
+// response fails the stream without claiming that an unencoded response ran.
+//
+//  1. Reject protocol negotiation before a graph session is constructed.
+//  2. Fail the response writer and require a nonzero server result.
+//  3. Require the stderr cause while forbidding successful phase rows.
+func TestServeEarlyErrorEncodeFailureIsObservable(t *testing.T) {
+  root := graphSessionFixture(t)
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+
+  var diagnostic bytes.Buffer
+  stderr = &diagnostic
+  request := "{\"id\":29,\"graphSnapshotVersion\":99}\n"
+  if code := serveSnapshots(strings.NewReader(request), rejectedServeWriter{}, root, "tsconfig.json"); code == 0 {
+    t.Fatal("failed early error encoding returned success")
+  }
+  if !strings.Contains(diagnostic.String(), "write serve response: synthetic response write failure") {
+    t.Fatalf("failed early error encoding hid its cause: %q", diagnostic.String())
+  }
+  if strings.Contains(diagnostic.String(), "ttscgraph-phase") {
+    t.Fatalf("failed early error encoding claimed successful phase rows: %q", diagnostic.String())
+  }
+}

package/cmd/ttscgraph/serve_graph_snapshot_version_matches_typescript_client_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "regexp"
+  "strconv"
+  "testing"
+)
+
+// TestServeGraphSnapshotVersionMatchesTypeScriptClient verifies the native
+// opt-in number and the resident client move together. The outer serve protocol
+// stays backward compatible, so only this explicit negotiation field can stop
+// an old full-dump client from misreading a shard response.
+func TestServeGraphSnapshotVersionMatchesTypeScriptClient(t *testing.T) {
+  source := filepath.Join("..", "..", "..", "graph", "src", "model", "TtscGraphSession.ts")
+  content, err := os.ReadFile(source)
+  if err != nil {
+    t.Fatal(err)
+  }
+  match := regexp.MustCompile(`const GRAPH_SNAPSHOT_PROTOCOL_VERSION = ([0-9]+);`).FindSubmatch(content)
+  if len(match) != 2 {
+    t.Fatalf("could not find GRAPH_SNAPSHOT_PROTOCOL_VERSION in %s", source)
+  }
+  version, err := strconv.Atoi(string(match[1]))
+  if err != nil {
+    t.Fatal(err)
+  }
+  if version != graphSnapshotProtocolVersion {
+    t.Fatalf("TypeScript client graph snapshot protocol v%d, native server v%d", version, graphSnapshotProtocolVersion)
+  }
+}

package/cmd/ttscgraph/serve_phase_trace_accounts_for_load_failure_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestServePhaseTraceAccountsForLoadFailure proves addressed requests retain a
+// complete timing record even when no resident compiler session can be built.
+//
+//  1. Request a missing tsconfig with phase tracing enabled.
+//  2. Require a normal addressed error response rather than process failure.
+//  3. Require all five payload-free phases under mode=error.
+func TestServePhaseTraceAccountsForLoadFailure(t *testing.T) {
+  root := graphSessionFixture(t)
+  request := "{\"id\":23,\"graphSnapshotVersion\":1}\n"
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+
+  var output bytes.Buffer
+  var trace bytes.Buffer
+  stderr = &trace
+  if code := serveSnapshots(strings.NewReader(request), &output, root, "missing-tsconfig.json"); code != 0 {
+    t.Fatalf("failed load exited %d", code)
+  }
+  if !strings.Contains(output.String(), `"id":23`) || !strings.Contains(output.String(), `"mode":"error"`) {
+    t.Fatalf("failed load omitted its addressed error response: %q", output.String())
+  }
+  for _, phase := range []string{
+    "native-load",
+    "semantic-refresh",
+    "shard-export",
+    "encode",
+    "producer-total",
+  } {
+    if !strings.Contains(trace.String(), "owner=producer request=23 mode=error phase="+phase+" durationMs=") {
+      t.Fatalf("failed-load trace omitted %s: %q", phase, trace.String())
+    }
+  }
+  if strings.Contains(trace.String(), root) || strings.Contains(trace.String(), "missing-tsconfig") || strings.Contains(trace.String(), "{\"") {
+    t.Fatalf("failed-load trace exposed request or project content: %q", trace.String())
+  }
+}

package/cmd/ttscgraph/serve_phase_trace_is_opt_in_and_payload_free_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestServePhaseTraceIsOptInAndPayloadFree proves the benchmark diagnostic is
+// disabled by default and exposes timings without project or request content.
+//
+//  1. Run the same native shard request with tracing disabled and enabled.
+//  2. Capture only the server diagnostic stream, not the response payload.
+//  3. Require the five named phases and reject fixture paths and JSON bodies.
+func TestServePhaseTraceIsOptInAndPayloadFree(t *testing.T) {
+  root := graphSessionFixture(t)
+  request := "{\"id\":17,\"graphSnapshotVersion\":1}\n"
+  oldStderr := stderr
+  defer func() { stderr = oldStderr }()
+
+  t.Setenv(graphPhaseTraceEnvironment, "")
+  var disabled bytes.Buffer
+  stderr = &disabled
+  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("disabled trace exited %d", code)
+  }
+  if disabled.Len() != 0 {
+    t.Fatalf("disabled trace wrote %q", disabled.String())
+  }
+
+  t.Setenv(graphPhaseTraceEnvironment, "1")
+  var enabled bytes.Buffer
+  stderr = &enabled
+  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("enabled trace exited %d", code)
+  }
+  trace := enabled.String()
+  for _, phase := range []string{
+    "native-load",
+    "semantic-refresh",
+    "shard-export",
+    "encode",
+    "producer-total",
+  } {
+    if !strings.Contains(trace, "owner=producer request=17 mode=initial phase="+phase+" durationMs=") {
+      t.Fatalf("trace omitted %s: %q", phase, trace)
+    }
+  }
+  if strings.Contains(trace, root) || strings.Contains(trace, "graphSnapshotVersion") || strings.Contains(trace, "{\"") {
+    t.Fatalf("trace exposed request or project content: %q", trace)
+  }
+}

package/cmd/ttscgraph/serve_protocol_negotiates_incremental_shards_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestServeProtocolNegotiatesIncrementalShards pins the opt-in boundary between
+// existing full-dump clients and the native shard protocol. A negotiated first
+// response carries one complete manifest and transaction, while the following
+// no-op carries neither a dump nor a shard payload.
+func TestServeProtocolNegotiatesIncrementalShards(t *testing.T) {
+  root := graphSessionFixture(t)
+  input := strings.NewReader("{\"id\":1,\"graphSnapshotVersion\":1}\n{\"id\":2,\"graphSnapshotVersion\":1}\n")
+  var output bytes.Buffer
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d", code)
+  }
+
+  decoder := json.NewDecoder(&output)
+  var initial serveResponse
+  var unchanged serveResponse
+  if err := decoder.Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&unchanged); err != nil {
+    t.Fatal(err)
+  }
+  if initial.Error != "" || initial.Mode != serveModeInitial || !initial.Changed || initial.Dump != nil || initial.Snapshot == nil {
+    t.Fatalf("negotiated initial response: %#v", initial)
+  }
+  snapshot := initial.Snapshot
+  if snapshot.ProtocolVersion != graphSnapshotProtocolVersion || snapshot.Sequence != 1 || snapshot.BaseSequence != 0 || snapshot.BaseGeneration != "" {
+    t.Fatalf("initial transaction coordinates: %#v", snapshot)
+  }
+  if len(snapshot.Manifest) == 0 || len(snapshot.Upserts) != len(snapshot.Manifest) || len(snapshot.Deletes) != 0 {
+    t.Fatalf("initial transaction is not complete: manifest=%d upserts=%d deletes=%d", len(snapshot.Manifest), len(snapshot.Upserts), len(snapshot.Deletes))
+  }
+  if unchanged.Error != "" || unchanged.Mode != serveModeUnchanged || unchanged.Changed || unchanged.Dump != nil || unchanged.Snapshot != nil {
+    t.Fatalf("negotiated unchanged response: %#v", unchanged)
+  }
+}

package/cmd/ttscgraph/serve_session_reloads_commonjs_package_entry_for_esm_test.go

@@ -39,12 +39,12 @@ func TestServeSessionReloadsCommonJSPackageEntryForESM(t *testing.T) {
     t.Fatal(err)
   }
 
-  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "main.ts"), "export function winner(): void {}\nexport function packageEntryWinner(): void {}\n")
+  writeGraphFile(t, filepath.Join(root, "node_modules", "fixture-package", "dist", "main.ts"), "export function winner(): void {}\n")
   dump, mode, changed, err := session.Snapshot()
   if err != nil {
     t.Fatal(err)
   }
-  if dump == nil || mode != serveModeReload || !changed || !hasDumpNode(*dump, "packageEntryWinner") {
+  if dump == nil || mode != serveModeReload || !changed || !hasDumpNodeAt(*dump, "winner", "node_modules/fixture-package/dist/main.ts") {
     t.Fatalf("CommonJS package main.ts = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
   }
 }