ttsc 0.23.0 → 0.24.0

package/cmd/ttscgraph/serve_shards_refresh_cross_file_implementation_test.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestServeShardsRefreshCrossFileImplementation verifies that an assignment
+// source and the declaration node whose implementation span it owns enter one
+// replacement transaction.
+func TestServeShardsRefreshCrossFileImplementation(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  service := filepath.Join(root, "src", "service.ts")
+  install := filepath.Join(root, "src", "install.ts")
+  writeGraphFile(t, service, "export class Service { run(): void {} }\n")
+  writeGraphFile(t, install, "import { Service } from './service';\nexport function helper(): void {}\nexport function install(value: Service): void { value.run = (): void => { helper(); }; }\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)
+  }
+  serviceSource := session.compiler.Program().SourceFile(service)
+  if serviceSource == nil {
+    t.Fatal("service source was absent from resident program")
+  }
+  serviceKey := session.graphStore.sourceKeys[serviceSource.FileName()]
+  before := session.graphStore.shards[serviceKey].digest
+  evidenceFile := ""
+  for _, edge := range session.graphStore.shards[serviceKey].shard.Edges {
+    if strings.Contains(edge.From, "#Service.run:method") && strings.Contains(edge.To, "#helper:function") && edge.Evidence != nil {
+      evidenceFile = edge.Evidence.File
+      break
+    }
+  }
+  if evidenceFile != "src/install.ts" {
+    t.Fatalf("cross-file implementation edge evidence = %q", evidenceFile)
+  }
+
+  if err := os.WriteFile(install, []byte("import { Service } from './service';\nexport function helper(): void {}\nexport function install(value: Service): void { void value; }\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("cross-file implementation edit = snapshot:%v mode:%q changed:%v", snapshot != nil, mode, changed)
+  }
+  if session.graphStore.shards[serviceKey].digest == before {
+    t.Fatal("declaration shard retained its cross-file implementation evidence")
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_refresh_dependent_diagnostics_test.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsRefreshDependentDiagnostics proves a public API edit rebuilds
+// the reverse semantic closure. The dependent source text is unchanged while
+// its checker diagnostic changes, so reusing that shard would be stale.
+//
+//  1. Commit a producer and consumer whose public types initially agree.
+//  2. Change only the producer's exported return type.
+//  3. Require both sources to be re-extracted and the new consumer diagnostic
+//     to be transmitted in its replacement shard.
+func TestServeShardsRefreshDependentDiagnostics(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  value := filepath.Join(root, "src", "value.ts")
+  consumer := filepath.Join(root, "src", "consumer.ts")
+  writeGraphFile(t, value, "export function value(): number { return 1; }\n")
+  writeGraphFile(t, consumer, "import { value } from './value';\nexport const consumed: number = value();\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)
+  }
+  consumerSource := session.compiler.Program().SourceFile(consumer)
+  if consumerSource == nil {
+    t.Fatal("consumer source was absent from resident program")
+  }
+  consumerKey := session.graphStore.sourceKeys[consumerSource.FileName()]
+  before := session.graphStore.shards[consumerKey].digest
+
+  if err := os.WriteFile(value, []byte("export function value(): string { return 'one'; }\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("public API edit = snapshot:%v mode:%q changed:%v", snapshot != nil, mode, changed)
+  }
+  after := session.graphStore.shards[consumerKey].digest
+  if after == before {
+    t.Fatal("dependent diagnostic retained its previous shard digest")
+  }
+  upserted := false
+  for _, upsert := range snapshot.Upserts {
+    if upsert.Shard.Key == consumerKey {
+      upserted = true
+      break
+    }
+  }
+  if !upserted {
+    t.Fatal("public API edit did not transmit the changed dependent shard")
+  }
+  valueKeyFile := session.compiler.Program().SourceFile(value).FileName()
+  consumerKeyFile := consumerSource.FileName()
+  if len(session.graphStore.extractedFiles) != 2 ||
+    session.graphStore.extractedFiles[0] != consumerKeyFile ||
+    session.graphStore.extractedFiles[1] != valueKeyFile {
+    t.Fatalf(
+      "public API edit extracted %v, want reverse closure [%s %s]",
+      session.graphStore.extractedFiles,
+      consumerKeyFile,
+      valueKeyFile,
+    )
+  }
+  assertServeShardFactsMatchFullDump(t, session)
+}

package/cmd/ttscgraph/serve_shards_rename_moves_source_identity_test.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeShardsRenameMovesSourceIdentity verifies a renamed source deletes its
+// old shard and publishes a new one whose coordinates name the new path.
+//
+// A rename is a delete and a create at the filesystem layer but not at the
+// resolution layer: the old path can still be imported, and the shard key binds
+// the path, so carrying the old identity forward would leave the consumer with
+// two coordinates for one declaration. The dependent's import is rewritten in
+// the same step, which is what keeps the program resolvable and proves the
+// closure covers both ends of the move.
+//
+//  1. Commit a project whose consumer imports a source by its original path.
+//  2. Rename that source and repoint the import in the same generation.
+//  3. Require the old shard deleted, a new shard published, and the dependent replaced.
+func TestServeShardsRenameMovesSourceIdentity(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  original := filepath.Join(root, "src", "original.ts")
+  consumerFile := filepath.Join(root, "src", "consumer.ts")
+  writeGraphFile(t, original, "export function moved(): number { return 3; }\n")
+  writeGraphFile(t, consumerFile, "import { moved } from './original';\nexport function consume(): number { return moved(); }\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)
+  }
+  originalSource := session.compiler.Program().SourceFile(original)
+  consumerSource := session.compiler.Program().SourceFile(consumerFile)
+  if originalSource == nil || consumerSource == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  originalKeyFile := originalSource.FileName()
+  consumerKeyFile := consumerSource.FileName()
+  originalKey := session.graphStore.sourceKeys[originalKeyFile]
+  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  if originalKey == "" || initialConsumerKey == "" {
+    t.Fatal("initial generation omitted a fixture source shard")
+  }
+
+  renamed := filepath.Join(root, "src", "renamed.ts")
+  if err := os.Rename(original, renamed); err != nil {
+    t.Fatal(err)
+  }
+  writeGraphFile(t, consumerFile, "import { moved } from './renamed';\nexport function consume(): number { return moved(); }\n")
+
+  next, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if next == nil || !changed || next.BaseGeneration != initial.Generation {
+    t.Fatalf("rename generation = snapshot:%#v mode:%q changed:%v", next, mode, changed)
+  }
+  if !containsString(next.Deletes, originalKey) {
+    t.Fatalf("rename did not delete the superseded shard %q: %v", originalKey, next.Deletes)
+  }
+  if _, exists := session.graphStore.sourceKeys[originalKeyFile]; exists {
+    t.Fatal("committed store retained the pre-rename source identity")
+  }
+  renamedSource := session.compiler.Program().SourceFile(renamed)
+  if renamedSource == nil {
+    t.Fatal("renamed source did not enter the resident program")
+  }
+  renamedKey := session.graphStore.sourceKeys[renamedSource.FileName()]
+  if renamedKey == "" {
+    t.Fatal("renamed source did not acquire a committed shard identity")
+  }
+  if renamedKey == originalKey {
+    t.Fatalf("renamed source reused the pre-rename shard key %q", renamedKey)
+  }
+  if !containsUpsertedShardKey(next, renamedKey) {
+    t.Fatalf("generation did not publish the renamed source shard %q", renamedKey)
+  }
+  nextConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  if nextConsumerKey == initialConsumerKey {
+    t.Fatalf("dependent shard identity %q survived a repointed import", nextConsumerKey)
+  }
+}

package/cmd/ttscgraph/serve_shards_retry_preserves_committed_generation_test.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestServeShardsRetryPreservesCommittedGeneration verifies projection failure
+// cannot advance the native shard store. The same captured compiler change is
+// retried against the prior base and publishes exactly the next sequence only
+// after every replacement validates.
+func TestServeShardsRetryPreservesCommittedGeneration(t *testing.T) {
+  root := graphSessionFixture(t)
+  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)
+  }
+  committed := session.graphStore
+  file := filepath.Join(root, "src", "index.ts")
+  if err := os.WriteFile(file, []byte("export class AfterRetry {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+
+  session.cwd = "relative-project"
+  snapshot, _, changed, err := session.SnapshotShards()
+  if err == nil || !strings.Contains(err.Error(), "project root") {
+    t.Fatalf("projection error = %v, want absolute-root rejection", err)
+  }
+  if snapshot != nil || changed || session.graphStore != committed || session.pending == nil {
+    t.Fatalf("failed transaction mutated publication state: snapshot:%v changed:%v store:%v pending:%v", snapshot != nil, changed, session.graphStore != committed, session.pending != nil)
+  }
+
+  session.cwd = root
+  recovered, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if recovered == nil || mode != serveModeIncremental || !changed || recovered.Sequence != initial.Sequence+1 || recovered.BaseGeneration != initial.Generation {
+    t.Fatalf("recovered transaction = snapshot:%#v mode:%q changed:%v", recovered, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_shards_reuse_unaffected_sources_test.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "runtime"
+  "testing"
+)
+
+// TestServeShardsReuseUnaffectedSources verifies a private body edit advances
+// only the changed content-addressed source shard. TypeScript's forced
+// declaration output proves the public shape stayed fixed, so neither the
+// dependent nor unrelated source is re-extracted or retransmitted.
+//
+//  1. Commit a project where one source has a dependent and an unrelated peer.
+//  2. Change only the source's private function body and request another shard snapshot.
+//  3. Require one extracted source and no dependent or unrelated shard replacement.
+func TestServeShardsReuseUnaffectedSources(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", "value.ts"), "export function value(): number { return 1; }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "consumer.ts"), "import { value } from './value';\nexport function consume(): number { return value(); }\n")
+  writeGraphFile(t, filepath.Join(root, "src", "unrelated.ts"), "export const unrelated = true;\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)
+  }
+  valueFile := filepath.Join(root, "src", "value.ts")
+  consumerFile := filepath.Join(root, "src", "consumer.ts")
+  unrelatedFile := filepath.Join(root, "src", "unrelated.ts")
+  valueSource := session.compiler.Program().SourceFile(valueFile)
+  consumerSource := session.compiler.Program().SourceFile(consumerFile)
+  unrelatedSource := session.compiler.Program().SourceFile(unrelatedFile)
+  if valueSource == nil || consumerSource == nil || unrelatedSource == nil {
+    t.Fatal("fixture source was absent from resident program")
+  }
+  valueKeyFile := valueSource.FileName()
+  consumerKeyFile := consumerSource.FileName()
+  unrelatedKeyFile := unrelatedSource.FileName()
+  initialValueKey := session.graphStore.sourceKeys[valueKeyFile]
+  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  initialUnrelatedKey := session.graphStore.sourceKeys[unrelatedKeyFile]
+  unrelatedWireFile := session.graphStore.wireSources[unrelatedKeyFile]
+  for index := range session.graphStore.provenance.Sources {
+    if session.graphStore.provenance.Sources[index].File != unrelatedKeyFile {
+      continue
+    }
+    if runtime.GOOS == "windows" {
+      volume := "C:"
+      if filepath.VolumeName(root) == volume {
+        volume = "Z:"
+      }
+      session.graphStore.provenance.Sources[index].File = volume + "/unrelated.ts"
+    } else {
+      session.graphStore.provenance.Sources[index].File = "//foreign/share/unrelated.ts"
+    }
+    break
+  }
+  if unrelatedWireFile == "" {
+    t.Fatal("unrelated source was absent from physical/wire provenance")
+  }
+  if err := os.WriteFile(valueFile, []byte("export function value(): number { return 2; }\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  delta, mode, changed, err := session.SnapshotShards()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if delta == nil || mode != serveModeIncremental || !changed || delta.BaseSequence != initial.Sequence || delta.BaseGeneration != initial.Generation {
+    t.Fatalf("incremental coordinates: snapshot=%#v mode=%q changed=%v", delta, mode, changed)
+  }
+  nextValueKey := session.graphStore.sourceKeys[valueKeyFile]
+  if nextValueKey == initialValueKey {
+    t.Fatal("changed source retained its content-addressed shard key")
+  }
+  if !containsString(delta.Deletes, initialValueKey) {
+    t.Fatalf("delta did not delete superseded source shard %q: %v", initialValueKey, delta.Deletes)
+  }
+  if session.graphStore.sourceKeys[consumerKeyFile] != initialConsumerKey || session.graphStore.sourceKeys[unrelatedKeyFile] != initialUnrelatedKey {
+    t.Fatal("body edit moved an unchanged source shard identity")
+  }
+  if len(session.graphStore.extractedFiles) != 1 || session.graphStore.extractedFiles[0] != valueKeyFile {
+    t.Fatalf("private body edit extracted %v, want only %s", session.graphStore.extractedFiles, valueKeyFile)
+  }
+  wireFilePreserved := false
+  for _, source := range session.graphStore.wireProvenance.Sources {
+    if source.File == unrelatedWireFile {
+      wireFilePreserved = true
+      break
+    }
+  }
+  if !wireFilePreserved {
+    t.Fatalf("unchanged wire provenance lost %q", unrelatedWireFile)
+  }
+  for _, upsert := range delta.Upserts {
+    if upsert.Shard.Key == initialConsumerKey || upsert.Shard.Key == initialUnrelatedKey {
+      t.Fatalf("delta retransmitted byte-identical shard %q", upsert.Shard.Key)
+    }
+  }
+}
+
+func containsString(values []string, expected string) bool {
+  for _, value := range values {
+    if value == expected {
+      return true
+    }
+  }
+  return false
+}

package/driver/declaration_shape.go

@@ -0,0 +1,85 @@
+package driver
+
+import (
+  "context"
+  "crypto/sha256"
+  "encoding/hex"
+  "fmt"
+  "strings"
+
+  "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// DeclarationShapeDigest hashes the declaration output TypeScript itself
+// derives for one source file. Resident consumers compare the old and new
+// values to distinguish a private body edit from a public semantic movement
+// before expanding invalidation through reverse dependencies.
+func (p *Program) DeclarationShapeDigest(file *ast.SourceFile) (string, error) {
+  if p == nil || p.TSProgram == nil || file == nil {
+    return "", fmt.Errorf("driver: declaration shape requires a loaded source file")
+  }
+  if err := p.ApplyLinkedPlugins(); err != nil {
+    return "", err
+  }
+  var signature strings.Builder
+  emitted := false
+  p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+    TargetSourceFile: file,
+    EmitOnly:         shimcompiler.EmitOnlyForcedDts,
+    WriteFile: func(_ string, text string, data *shimcompiler.WriteFileData) error {
+      emitted = true
+      if data != nil && data.SourceMapUrlPos >= 0 && data.SourceMapUrlPos <= len(text) {
+        text = text[:data.SourceMapUrlPos]
+      }
+      signature.WriteString(text)
+      if data != nil {
+        for _, diagnostic := range data.Diagnostics {
+          appendDeclarationShapeDiagnostic(&signature, file, diagnostic)
+        }
+      }
+      return nil
+    },
+  })
+  if !emitted {
+    // Mirrors tsgo's incremental fallback to the file version when forced
+    // declaration emit has no output. This is conservative: any body movement
+    // expands dependents instead of risking a stale semantic closure.
+    signature.WriteString(file.Text())
+  }
+  digest := sha256.Sum256([]byte(signature.String()))
+  return hex.EncodeToString(digest[:]), nil
+}
+
+func appendDeclarationShapeDiagnostic(builder *strings.Builder, source *ast.SourceFile, diagnostic *ast.Diagnostic) {
+  if diagnostic == nil {
+    return
+  }
+  builder.WriteString("\n")
+  diagnosticFile := diagnostic.File()
+  if diagnosticFile != nil && diagnosticFile != source {
+    builder.WriteString(shimtspath.EnsurePathIsNonModuleName(shimtspath.GetRelativePathFromDirectory(
+      shimtspath.GetDirectoryPath(string(source.Path())),
+      string(diagnosticFile.Path()),
+      shimtspath.ComparePathsOptions{},
+    )))
+  }
+  if diagnosticFile != nil {
+    builder.WriteString(fmt.Sprintf("(%d,%d): ", diagnostic.Pos(), diagnostic.Len()))
+  }
+  builder.WriteString(diagnostic.Category().Name())
+  builder.WriteString(fmt.Sprintf("%d: ", diagnostic.Code()))
+  builder.WriteString(string(diagnostic.MessageKey()))
+  builder.WriteString("\n")
+  for _, argument := range diagnostic.MessageArgs() {
+    builder.WriteString(argument)
+    builder.WriteString("\n")
+  }
+  for _, chain := range diagnostic.MessageChain() {
+    appendDeclarationShapeDiagnostic(builder, source, chain)
+  }
+  for _, related := range diagnostic.RelatedInformation() {
+    appendDeclarationShapeDiagnostic(builder, source, related)
+  }
+}

package/driver/program.go

@@ -513,8 +513,10 @@ func ApplySourcePreamble(text string, preamble string) string {
   return bom + preamble + rest
 }
 
-// SourceFiles exposes the program's user-authored source files (declaration
-// files filtered out).
+// SourceFiles exposes the program's resident non-declaration source files.
+// Imported implementation files from source-distributed dependencies can be
+// present; consumers that need project-owned files must apply their own root
+// predicate.
 func (p *Program) SourceFiles() []*ast.SourceFile {
   // Discarded on purpose; see SourceFile. `Diagnostics` carries the failure.
   _ = p.ApplyLinkedPlugins()
@@ -564,6 +566,19 @@ func (p *Program) HasLinkedProgramPlugins() bool {
 // Diagnostics returns project diagnostics that must block compilation or
 // runtime execution before any JavaScript is emitted or evaluated.
 func (p *Program) Diagnostics() []Diagnostic {
+  return p.diagnostics(nil)
+}
+
+// DiagnosticsForFiles returns diagnostics whose semantic work is restricted to
+// selected source files, plus the program/global diagnostics that qualify the
+// same immutable Program generation. The resident graph shard producer uses it
+// for the compiler-invalidated closure; callers that need the complete project
+// continue to use Diagnostics.
+func (p *Program) DiagnosticsForFiles(files []*ast.SourceFile) []Diagnostic {
+  return p.diagnostics(files)
+}
+
+func (p *Program) diagnostics(files []*ast.SourceFile) []Diagnostic {
   if p == nil || p.TSProgram == nil {
     return []Diagnostic{{Message: "driver: nil program"}}
   }
@@ -600,14 +615,28 @@ func (p *Program) Diagnostics() []Diagnostic {
     })
   }
   ctx := context.Background()
-  raw := shimcompiler.GetDiagnosticsOfAnyProgram(
-    ctx,
-    p.TSProgram,
-    nil,
-    false,
-    p.TSProgram.GetBindDiagnostics,
-    p.TSProgram.GetSemanticDiagnostics,
-  )
+  var raw []*ast.Diagnostic
+  if files == nil {
+    raw = shimcompiler.GetDiagnosticsOfAnyProgram(
+      ctx,
+      p.TSProgram,
+      nil,
+      false,
+      p.TSProgram.GetBindDiagnostics,
+      p.TSProgram.GetSemanticDiagnostics,
+    )
+  } else {
+    for _, file := range files {
+      raw = append(raw, shimcompiler.GetDiagnosticsOfAnyProgram(
+        ctx,
+        p.TSProgram,
+        file,
+        false,
+        p.TSProgram.GetBindDiagnostics,
+        p.TSProgram.GetSemanticDiagnostics,
+      )...)
+    }
+  }
   raw = filterDiagnostics(raw)
   return append(out, convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))...)
 }

package/internal/graph/build.go

@@ -8,23 +8,53 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// Build walks the program's user-authored source files and records a node for
-// each top-level declaration. driver.SourceFiles already drops declaration files
-// and the program never compiles a dependency's `.ts`, so every node Build emits
-// is workspace source: External is false. External boundary leaves enter the
-// graph only as the resolved target of an edge (see Resolve).
+// Build walks the program's workspace source files and records a node for
+// each top-level declaration. The checker can load a dependency's raw `.ts`
+// entry, so IsWorkspaceSourceFile owns the declaration boundary instead of
+// assuming every non-declaration source is authored here. External boundary
+// leaves enter the graph only as the resolved target of an edge (see Resolve).
 func Build(prog *driver.Program) *Graph {
+  return BuildFiles(prog, nil, nil)
+}
+
+// BuildFiles resolves graph facts owned by selected source files against one
+// immutable Program. A nil selection preserves Build's complete-project
+// behavior. A non-nil selection emits only replacement nodes and outgoing
+// facts for those files while using baseNodes as a read-only endpoint index.
+//
+// This is the semantic primitive a resident shard store needs: an ordinary edit
+// asks the new checker only about its invalidated closure instead of walking
+// every declaration again, while cross-file targets retain the exact stable IDs
+// established by the preceding committed generation.
+func BuildFiles(prog *driver.Program, selected []string, baseNodes map[string]*Node) *Graph {
+  selectedFiles := map[string]bool{}
+  if selected != nil {
+    for _, file := range selected {
+      selectedFiles[file] = true
+    }
+  }
   g := &Graph{
-    Nodes:     map[string]*Node{},
-    bodyNodes: map[string]bool{},
-    seen:      map[edgeKey]struct{}{},
-    resolved:  map[*shimast.Node]*Target{},
+    Nodes:                 map[string]*Node{},
+    bodyNodes:             map[string]bool{},
+    seen:                  map[edgeKey]struct{}{},
+    resolved:              map[*shimast.Node]*Target{},
+    edgeEvidenceFiles:     map[string]string{},
+    baseNodes:             baseNodes,
+    selectedFiles:         selectedFiles,
+    ExportedTargets:       map[string]bool{},
+    ImplementationSources: map[string]map[string]bool{},
   }
   for _, file := range prog.SourceFiles() {
+    if !IsWorkspaceSourceFile(file) {
+      continue
+    }
+    if selected != nil && !selectedFiles[file.FileName()] {
+      continue
+    }
     g.putModuleNode(file)
     collectDeclarations(g, file)
   }
-  g.addEdges(prog)
+  g.addEdges(prog, selectedFiles, selected != nil)
   return g
 }
 
@@ -49,6 +79,28 @@ func SourceTexts(prog *driver.Program) map[string]string {
   return out
 }
 
+// SourceTextsForFiles returns resident checker text only for the named source
+// files. It is the partial-build counterpart of SourceTexts: selected graph
+// shards still receive exact evidence and signatures, without walking or
+// retaining every unchanged source body again.
+func SourceTextsForFiles(prog *driver.Program, files []string) map[string]string {
+  if prog == nil || prog.TSProgram == nil {
+    return map[string]string{}
+  }
+  _ = prog.ApplyLinkedPlugins()
+  selected := make(map[string]bool, len(files))
+  for _, file := range files {
+    selected[file] = true
+  }
+  out := make(map[string]string, len(files))
+  for _, source := range prog.TSProgram.SourceFiles() {
+    if source != nil && selected[source.FileName()] {
+      out[source.FileName()] = source.Text()
+    }
+  }
+  return out
+}
+
 // collectDeclarations records a node for each declaration statement in file,
 // plus a method node for each callable member of a class or interface, so
 // method-to-method calls have both endpoints. It descends into namespace bodies