ttsc 0.23.0 → 0.25.0

package/cmd/ttscgraph/serve_shards_abandoned_generation_converges_on_retry_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsAbandonedGenerationConvergesOnRetry verifies a consumer that
+// abandons a request mid-flight can still converge, and that the facts it
+// eventually commits match the ones it discarded.
+//
+// The producer has no abort path: it commits after the projection succeeds, so
+// a client that walks away leaves the producer's committed generation ahead of
+// the consumer's. Cancellation is therefore discharged by base negotiation
+// rather than by cancellation handling, which is sound only if the abandoned
+// generation is not the sole carrier of its facts. A consumer replaying from
+// its own stale base has to receive those same facts again.
+//
+//  1. Commit one generation, then edit and take a generation the client discards.
+//  2. Edit again and take the generation a recovered client would actually read.
+//  3. Require the store to have advanced once per accepted call and the final
+//     shard for the edited source to carry the latest text, not the abandoned one.
+func TestServeShardsAbandonedGenerationConvergesOnRetry(t *testing.T) {
+  root := graphSessionFixture(t)
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  committed, _, _, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  file := filepath.Join(root, "src", "index.ts")
+  indexSource := session.compiler.Program().SourceFile(file)
+  if indexSource == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  indexKeyFile := indexSource.FileName()
+
+  // The generation the client asks for and then abandons before reading.
+  if err := os.WriteFile(file, []byte("export class Abandoned {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  abandoned, _, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if abandoned == nil || !changed || abandoned.BaseGeneration != committed.Generation {
+    t.Fatalf("abandoned generation = snapshot:%#v changed:%v", abandoned, changed)
+  }
+  abandonedKey := session.graphStore.sourceKeys[indexKeyFile]
+
+  // The producer moved on regardless. A later edit plus the client's retry has
+  // to publish a generation that supersedes the abandoned one rather than
+  // depending on the consumer having applied it.
+  if err := os.WriteFile(file, []byte("export class Converged {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  converged, _, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if converged == nil || !changed {
+    t.Fatalf("converged generation = snapshot:%#v changed:%v", converged, changed)
+  }
+  if converged.BaseGeneration != abandoned.Generation {
+    t.Fatalf(
+      "converged base = %q, want the abandoned generation %q the producer actually committed",
+      converged.BaseGeneration,
+      abandoned.Generation,
+    )
+  }
+  if converged.Sequence != abandoned.Sequence+1 {
+    t.Fatalf("converged sequence = %d, want %d", converged.Sequence, abandoned.Sequence+1)
+  }
+  convergedKey := session.graphStore.sourceKeys[indexKeyFile]
+  if convergedKey == "" || convergedKey == abandonedKey {
+    t.Fatalf("edited source kept the abandoned shard identity %q", convergedKey)
+  }
+  if !containsUpsertedShardKey(converged, convergedKey) {
+    t.Fatalf("converged generation did not publish the latest shard %q", convergedKey)
+  }
+  if !containsString(converged.Deletes, abandonedKey) {
+    t.Fatalf(
+      "converged generation did not supersede the abandoned shard %q: %v",
+      abandonedKey,
+      converged.Deletes,
+    )
+  }
+}

package/cmd/ttscgraph/serve_shards_delete_removed_source_test.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsDeleteRemovedSource verifies a root-set reload names the
+// superseded source shard explicitly while publishing a complete replacement
+// generation. A consumer never has to infer deletion from a missing payload.
+func TestServeShardsDeleteRemovedSource(t *testing.T) {
+  root := graphSessionFixture(t)
+  keep := filepath.Join(root, "src", "keep.ts")
+  writeGraphFile(t, keep, "export const keep = true;\n")
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  initial, _, _, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  removed := filepath.Join(root, "src", "index.ts")
+  removedSource := session.compiler.Program().SourceFile(removed)
+  keepSource := session.compiler.Program().SourceFile(keep)
+  if removedSource == nil || keepSource == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  removedKeyFile := removedSource.FileName()
+  keepKeyFile := keepSource.FileName()
+  removedKey := session.graphStore.sourceKeys[removedKeyFile]
+  if removedKey == "" {
+    t.Fatal("initial generation omitted removable source shard")
+  }
+  if err := os.Remove(removed); err != nil {
+    t.Fatal(err)
+  }
+
+  replacement, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if replacement == nil || mode != serveModeReload || !changed || replacement.BaseGeneration != initial.Generation {
+    t.Fatalf("replacement generation = snapshot:%#v mode:%q changed:%v", replacement, mode, changed)
+  }
+  if !containsString(replacement.Deletes, removedKey) {
+    t.Fatalf("replacement did not delete removed source shard %q: %v", removedKey, replacement.Deletes)
+  }
+  if _, exists := session.graphStore.sourceKeys[removedKeyFile]; exists {
+    t.Fatal("committed store retained removed source identity")
+  }
+  if session.graphStore.sourceKeys[keepKeyFile] == "" {
+    t.Fatal("replacement generation dropped remaining source")
+  }
+}

package/cmd/ttscgraph/serve_shards_external_endpoints_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+func TestServeShardsKeepReferencedExternalEndpointsOnIncrementalLane(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "api.d.ts"), "export declare function external(): number;\n")
+  index := filepath.Join(root, "src", "index.ts")
+  writeGraphFile(t, index, "import { external } from './api';\nexport function local(): number { return external() + 1; }\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if snapshot, _, _, err := session.SnapshotShards(); err != nil || snapshot == nil {
+    t.Fatalf("initial shard snapshot = snapshot:%v error:%v", snapshot != nil, err)
+  }
+  if err := os.WriteFile(index, []byte("import { external } from './api';\nexport function local(): number { return external() + 2; }\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  snapshot, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if snapshot == nil || mode != serveModeIncremental || !changed {
+    t.Fatalf("external endpoint edit = snapshot:%v mode:%q changed:%v", snapshot != nil, mode, changed)
+  }
+  retained := false
+  for _, node := range session.graphStore.nodes {
+    if node.External && node.Name == "external" {
+      retained = true
+      break
+    }
+  }
+  if !retained {
+    t.Fatalf(
+      "referenced external endpoint left the internal base-node cache: nodes=%#v references=%#v external=%#v",
+      session.graphStore.nodes,
+      session.graphStore.externalReferences,
+      session.graphStore.externalNodes,
+    )
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_keep_source_distributed_dependencies_at_the_boundary_test.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestServeShardsKeepSourceDistributedDependenciesAtTheBoundary proves the
+// incremental store owns only workspace declarations while provenance still
+// attests to every source the resident checker loaded.
+//
+// 1. Snapshot one workspace source that imports a raw TypeScript package.
+// 2. Assert the dependency owns provenance but no authored graph facts.
+// 3. Edit the dependency and assert the store publishes a complete replacement.
+// 4. Compare the replacement store with the full-dump oracle.
+func TestServeShardsKeepSourceDistributedDependenciesAtTheBoundary(t *testing.T) {
+  root := t.TempDir()
+  dependencyPath := filepath.Join(root, "node_modules", "dep-src", "src", "index.ts")
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "files": ["src/main.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "node_modules", "dep-src", "package.json"), `{
+  "name": "dep-src",
+  "version": "1.0.0",
+  "main": "src/index.ts"
+}`)
+  writeGraphFile(t, dependencyPath, "export function dependencyValue(): number { return 1; }\nexport function dependencyInternal(): number { return dependencyValue(); }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "import { dependencyValue } from 'dep-src';\nexport function workspaceValue(): number { return dependencyValue() + 1; }\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if snapshot, _, _, err := session.SnapshotShards(); err != nil || snapshot == nil {
+    t.Fatalf("initial shard snapshot = snapshot:%v error:%v", snapshot != nil, err)
+  }
+
+  dependencyFile := ""
+  dependencyDigest := ""
+  for _, source := range session.graphStore.provenance.Sources {
+    if strings.Contains(filepath.ToSlash(source.File), "/node_modules/dep-src/") {
+      dependencyFile = source.File
+      dependencyDigest = source.Checker
+      break
+    }
+  }
+  if dependencyFile == "" {
+    t.Fatal("raw dependency source is absent from provenance")
+  }
+  for _, file := range session.graphStore.extractedFiles {
+    if file == dependencyFile {
+      t.Fatalf("raw dependency source was treated as an authored extraction: %v", session.graphStore.extractedFiles)
+    }
+  }
+  dependencyShard, ok := session.graphStore.shards[session.graphStore.sourceKeys[dependencyFile]]
+  if !ok || dependencyShard.shard.Source == nil {
+    t.Fatalf("dependency provenance shard missing for %q", dependencyFile)
+  }
+  if len(dependencyShard.shard.Nodes) != 0 || len(dependencyShard.shard.Edges) != 0 {
+    t.Fatalf("dependency provenance shard owns graph facts: nodes=%v edges=%v", dependencyShard.shard.Nodes, dependencyShard.shard.Edges)
+  }
+
+  boundaryFound := false
+  for _, node := range session.graphStore.nodes {
+    normalized := filepath.ToSlash(node.File)
+    if strings.Contains(normalized, "/node_modules/dep-src/") {
+      if !node.External || node.Name != "dependencyValue" {
+        t.Fatalf("unexpected dependency graph node: %+v", node)
+      }
+      boundaryFound = true
+    }
+  }
+  if !boundaryFound {
+    t.Fatal("referenced dependency boundary leaf is absent")
+  }
+
+  writeGraphFile(t, dependencyPath, "export function dependencyValue(): number { return 2; }\nexport function dependencyInternal(): number { return dependencyValue(); }\n")
+  replacement, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if replacement == nil {
+    t.Fatal("dependency edit did not publish a shard snapshot")
+  }
+  if mode != serveModeRebuild || !changed || len(replacement.Upserts) != len(replacement.Manifest) {
+    t.Fatalf(
+      "dependency edit should report and publish a complete rebuild: mode=%q changed=%v manifest=%d upserts=%d",
+      mode,
+      changed,
+      len(replacement.Manifest),
+      len(replacement.Upserts),
+    )
+  }
+  dependencyDigestChanged := false
+  for _, source := range session.graphStore.provenance.Sources {
+    if source.File == dependencyFile && source.Checker != dependencyDigest {
+      dependencyDigestChanged = true
+      break
+    }
+  }
+  if !dependencyDigestChanged {
+    t.Fatal("raw dependency edit did not refresh checker provenance")
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_match_full_dump_oracle_test.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "reflect"
+  "sort"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestServeShardsMatchFullDumpOracle proves the initial transaction and one
+// accepted edit reconstruct exactly the facts the complete builder produces.
+// This keeps shard ownership and base-node reuse as an optimization boundary,
+// never a second semantic contract.
+func TestServeShardsMatchFullDumpOracle(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "base.ts"), "export interface Base { run(): void; }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "impl.ts"), "import { Base } from './base';\nexport class Impl implements Base { run(): void {} }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "consumer.ts"), "import { Impl } from './impl';\nexport function consume(): void { new Impl().run(); }\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if snapshot, _, _, err := session.SnapshotShards(); err != nil || snapshot == nil {
+    t.Fatalf("initial shard snapshot = snapshot:%v error:%v", snapshot != nil, err)
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+
+  impl := filepath.Join(root, "src", "impl.ts")
+  if err := os.WriteFile(impl, []byte("import { Base } from './base';\nexport class Impl implements Base { run(): void { const touched = true; void touched; } }\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  snapshot, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if snapshot == nil || mode != serveModeIncremental || !changed {
+    t.Fatalf("edited shard snapshot = snapshot:%v mode:%q changed:%v", snapshot != nil, mode, changed)
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}
+
+func assertServeShardFactsMatchFullDump(t *testing.T, session *graphSession) {
+  t.Helper()
+  complete, err := session.buildDump()
+  if err != nil {
+    t.Fatal(err)
+  }
+  var nodes []graph.DumpNode
+  var edges []graph.DumpEdge
+  var diagnostics []graph.Diagnostic
+  for _, committed := range session.graphStore.shards {
+    nodes = append(nodes, committed.shard.Nodes...)
+    edges = append(edges, committed.shard.Edges...)
+    diagnostics = append(diagnostics, committed.shard.Diagnostics...)
+  }
+  if !reflect.DeepEqual(canonicalJSONRows(nodes), canonicalJSONRows(complete.Nodes)) {
+    t.Fatal("committed shard nodes differ from complete-build oracle")
+  }
+  if !reflect.DeepEqual(canonicalJSONRows(edges), canonicalJSONRows(complete.Edges)) {
+    t.Fatal("committed shard edges differ from complete-build oracle")
+  }
+  if !reflect.DeepEqual(canonicalJSONRows(diagnostics), canonicalJSONRows(complete.Diagnostics)) {
+    t.Fatal("committed shard diagnostics differ from complete-build oracle")
+  }
+}
+
+func canonicalJSONRows[T any](values []T) []string {
+  rows := make([]string, 0, len(values))
+  for _, value := range values {
+    encoded, err := json.Marshal(value)
+    if err != nil {
+      panic(err)
+    }
+    rows = append(rows, string(encoded))
+  }
+  sort.Strings(rows)
+  return rows
+}

package/cmd/ttscgraph/serve_shards_merge_pending_and_new_edits_test.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsMergePendingAndNewEdits verifies a second disk edit cannot
+// replace the invalidation closure of an earlier uncommitted generation. Both
+// changed sources must enter the retry transaction before it can advance the
+// shard-store base.
+func TestServeShardsMergePendingAndNewEdits(t *testing.T) {
+  root := graphSessionFixture(t)
+  other := filepath.Join(root, "src", "other.ts")
+  writeGraphFile(t, other, "export class OtherBefore {}\n")
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if snapshot, _, _, err := session.SnapshotShards(); err != nil || snapshot == nil {
+    t.Fatalf("initial snapshot = snapshot:%v error:%v", snapshot != nil, err)
+  }
+
+  first := filepath.Join(root, "src", "index.ts")
+  if err := os.WriteFile(first, []byte("export class FirstAfter {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  session.cwd = "relative-project"
+  if _, _, _, err := session.SnapshotShards(); err == nil {
+    t.Fatal("first edit unexpectedly committed through invalid project root")
+  }
+  if session.pending == nil {
+    t.Fatal("failed first edit left no pending invalidation")
+  }
+
+  session.cwd = root
+  if err := os.WriteFile(other, []byte("export class OtherAfter {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  recovered, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if recovered == nil || mode != serveModeIncremental || !changed || session.pending != nil {
+    t.Fatalf("merged recovery = snapshot:%v mode:%q changed:%v pending:%v", recovered != nil, mode, changed, session.pending != nil)
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_prune_unreferenced_external_endpoints_test.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsPruneUnreferencedExternalEndpoints verifies an external leaf
+// leaves both resident endpoint indexes when its last owning edge disappears.
+func TestServeShardsPruneUnreferencedExternalEndpoints(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "api.d.ts"), "export declare function external(): number;\n")
+  index := filepath.Join(root, "src", "index.ts")
+  writeGraphFile(t, index, "import { external } from './api';\nexport function run(): number { return external(); }\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  if snapshot, _, _, err := session.SnapshotShards(); err != nil || snapshot == nil {
+    t.Fatalf("initial shard snapshot = snapshot:%v error:%v", snapshot != nil, err)
+  }
+  source := session.compiler.Program().SourceFile(index)
+  if source == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  sourceKey := session.graphStore.sourceKeys[source.FileName()]
+  var externalID string
+  for id := range session.graphStore.sourceExternal[sourceKey] {
+    externalID = id
+    break
+  }
+  if externalID == "" {
+    t.Fatal("fixture did not produce an external endpoint")
+  }
+
+  if err := os.WriteFile(index, []byte("import { external } from './api';\nexport function run(): number { return 1; }\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  snapshot, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if snapshot == nil || mode != serveModeIncremental || !changed {
+    t.Fatalf("external endpoint edit = snapshot:%v mode:%q changed:%v", snapshot != nil, mode, changed)
+  }
+  if session.graphStore.externalReferences[externalID] != 0 {
+    t.Fatalf("external endpoint %s retained a reference count", externalID)
+  }
+  if _, exists := session.graphStore.externalNodes[externalID]; exists {
+    t.Fatalf("external endpoint %s remained in the wire endpoint cache", externalID)
+  }
+  for id, node := range session.graphStore.nodes {
+    if node.External {
+      t.Fatalf("external endpoint %s remained in the internal endpoint cache as %s", externalID, id)
+    }
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_publish_created_source_test.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsPublishCreatedSource verifies a source that appears while the
+// session is resident enters the generation as its own shard and unblocks the
+// dependents that could not resolve it before.
+//
+// Deletion is proven explicitly, but its mirror is the case where a wrong
+// closure is invisible: the consumer holds a graph that simply lacks a file,
+// and an agent asking about it is told the symbol does not exist rather than
+// receiving an error. The dependent must also refresh, because the import that
+// previously failed to resolve now produces real cross-file facts.
+//
+//  1. Commit a project whose consumer imports a module that does not exist yet.
+//  2. Create that module and request another shard snapshot.
+//  3. Require a shard for the new source and a replaced shard for its dependent.
+func TestServeShardsPublishCreatedSource(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  consumerFile := filepath.Join(root, "src", "consumer.ts")
+  writeGraphFile(t, consumerFile, "import { later } from './later';\nexport function consume(): number { return later(); }\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  initial, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if initial == nil || mode != serveModeInitial || !changed {
+    t.Fatalf("initial snapshot = snapshot:%v mode:%q changed:%v", initial != nil, mode, changed)
+  }
+  consumerSource := session.compiler.Program().SourceFile(consumerFile)
+  if consumerSource == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  consumerKeyFile := consumerSource.FileName()
+  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  if initialConsumerKey == "" {
+    t.Fatal("initial generation omitted the dependent source shard")
+  }
+
+  createdFile := filepath.Join(root, "src", "later.ts")
+  writeGraphFile(t, createdFile, "export function later(): number { return 7; }\n")
+
+  next, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if next == nil || !changed || next.BaseGeneration != initial.Generation {
+    t.Fatalf("created-source generation = snapshot:%#v mode:%q changed:%v", next, mode, changed)
+  }
+  createdSource := session.compiler.Program().SourceFile(createdFile)
+  if createdSource == nil {
+    t.Fatal("created source did not enter the resident program")
+  }
+  createdKey := session.graphStore.sourceKeys[createdSource.FileName()]
+  if createdKey == "" {
+    t.Fatal("created source did not acquire a committed shard identity")
+  }
+  if !containsUpsertedShardKey(next, createdKey) {
+    t.Fatalf("generation did not publish the created source shard %q", createdKey)
+  }
+  // The dependent's import resolved for the first time, so its cross-file facts
+  // changed even though its own text did not. Reusing its prior shard would
+  // publish a consumer graph with a call edge to nothing.
+  nextConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  if nextConsumerKey == initialConsumerKey {
+    t.Fatalf("dependent shard identity %q survived a newly resolved import", nextConsumerKey)
+  }
+  if !containsUpsertedShardKey(next, nextConsumerKey) {
+    t.Fatalf("generation did not republish the dependent shard %q", nextConsumerKey)
+  }
+}
+
+func containsUpsertedShardKey(snapshot *serveGraphSnapshot, expected string) bool {
+  for _, upsert := range snapshot.Upserts {
+    if upsert.Shard.Key == expected {
+      return true
+    }
+  }
+  return false
+}

package/cmd/ttscgraph/serve_shards_rebuild_declaration_edit_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsRebuildDeclarationEdit verifies that a declaration-file
+// movement publishes one honest complete replacement instead of entering the
+// authored-source partial builder with an empty invalidation set.
+func TestServeShardsRebuildDeclarationEdit(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  declaration := filepath.Join(root, "src", "api.d.ts")
+  writeGraphFile(t, declaration, "export declare function external(): number;\n")
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "import { external } from './api';\nexport const value = external();\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  initial, _, _, err := session.SnapshotShards()
+  if err != nil || initial == nil {
+    t.Fatalf("initial shard snapshot = snapshot:%v error:%v", initial != nil, err)
+  }
+  if err := os.WriteFile(declaration, []byte("export declare function external(): string;\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+
+  replacement, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if replacement == nil || mode != serveModeRebuild || !changed || replacement.BaseGeneration != initial.Generation {
+    t.Fatalf("declaration edit = snapshot:%#v mode:%q changed:%v", replacement, mode, changed)
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}