ttsc 0.30.3 → 0.31.0

package/cmd/ttscgraph/serve.go

@@ -18,6 +18,7 @@ import (
 
   shimtsoptions "github.com/microsoft/typescript-go/shim/tsoptions"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  shimvfs "github.com/microsoft/typescript-go/shim/vfs"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
   "github.com/samchon/ttsc/packages/ttsc/internal/graph"
@@ -35,7 +36,7 @@ import (
 // self-describing even when read from a log.
 const serveProtocolVersion = 1
 
-// serveModes are the computation modes Snapshot can report, plus the error mode
+// The serveMode* constants are the computation modes Snapshot can report, plus the error mode
 // the transport adds. A consumer branches on these to report honestly what the
 // producer did rather than inferring it from a generation counter.
 const (
@@ -91,8 +92,6 @@ func (s *graphSession) capabilities() []string {
   )
 }
 
-// artifactProducer names the second producer behind this session's artifact
-// nodes, and is nil when it has none.
 // provenance is this session's published origin for one generation.
 func (s *graphSession) provenance(texts map[string]string) graph.Provenance {
   built := graph.NewProvenance(
@@ -107,6 +106,8 @@ func (s *graphSession) provenance(texts map[string]string) graph.Provenance {
   return built
 }
 
+// artifactProducer names the second producer behind this session's artifact
+// nodes, and is nil when it has none.
 func (s *graphSession) artifactProducer() *graph.Producer {
   if len(s.artifacts) == 0 {
     return nil
@@ -116,9 +117,11 @@ func (s *graphSession) artifactProducer() *graph.Producer {
 
 type serveRequest struct {
   ID int `json:"id"`
+
   // GraphSnapshotVersion opts into the incremental shard protocol. Omitted
   // requests retain the full-dump response for existing @ttsc/graph clients.
   GraphSnapshotVersion int `json:"graphSnapshotVersion,omitempty"`
+
   // Artifacts is the path to the set a plugin published for this request, which
   // the client re-derives when the documents or lint configuration behind it
   // moved. It rides every request rather than only the changed ones: the client
@@ -137,21 +140,32 @@ type serveRequest struct {
 }
 
 type serveResponse struct {
-  Dump     *graph.Dump         `json:"dump,omitempty"`
+  // Dump carries a changed full projection for the legacy request protocol.
+  Dump *graph.Dump `json:"dump,omitempty"`
+
+  // Snapshot carries a changed shard transaction for the opted-in protocol.
   Snapshot *serveGraphSnapshot `json:"snapshot,omitempty"`
+
   // Error is set when the request produced no snapshot; Mode is then
   // serveModeError.
   Error string `json:"error,omitempty"`
-  ID    int    `json:"id"`
+
+  // ID addresses the response to the matching outstanding client request.
+  ID int `json:"id"`
+
   // ProtocolVersion is serveProtocolVersion on every response, including error
   // responses: a client that cannot parse the rest still learns why.
   ProtocolVersion int `json:"protocolVersion"`
-  // Mode is always present. It was omitempty, which meant the one field that
-  // distinguishes a reuse from a full rebuild silently vanished exactly when a
-  // consumer most wanted to report what happened.
-  Mode         string   `json:"mode"`
+
+  // Mode is always present: it is the one field that distinguishes a reuse
+  // from a full rebuild, so it must not vanish on any path.
+  Mode string `json:"mode"`
+
+  // Capabilities describe this session even when no changed dump is attached.
   Capabilities []string `json:"capabilities"`
-  Changed      bool     `json:"changed"`
+
+  // Changed is false for reuse and failure; neither publishes a new graph.
+  Changed bool `json:"changed"`
 }
 
 const graphPhaseTraceEnvironment = "SAMCHON_GRAPH_TTSC_PHASE_TRACE"
@@ -177,47 +191,44 @@ func errorResponse(id int, message string) serveResponse {
 type graphSession struct {
   cwd      string
   tsconfig string
+
   // artifacts is the set a plugin published: a second producer's facts about
   // documents this Program never read. Refreshing it is therefore not a refresh
   // of the graph — editing a Markdown heading moves the artifact and not one
   // compiler fact — so the two invalidations stay separate questions, and this
   // one is answered by adoptArtifacts rather than by the build universe.
   artifacts []graph.Artifact
+
   // artifactsDigest is the content of the set currently applied. Content, and
   // not the path or its modification time: the client overwrites one file per
   // process and project, so the path never moves for a given session, and a
   // republish triggered by a document whose headings did not actually change
-  // writes the same bytes and must therefore cost nothing.
+  // writes the same bytes and must therefore avoid decoding and projection.
   artifactsDigest [sha256.Size]byte
-  // artifactsFile and artifactsStat are what the digest was taken from, kept so
-  // an unchanged file need not be read at all. The set is one entry per
-  // document section, model field, and operation, so it is bounded by the
-  // project's documentation rather than by anything small — and this comparison
-  // runs before every graph request, where reading and hashing that whole file
-  // to learn it did not move is the kind of cost a resident session pays
-  // forever.
-  artifactsFile string
-  artifactsStat artifactsFileState
 
   compiler     *driver.Session
   configHashes map[string][sha256.Size]byte
   auxStates    map[string]diskState
   sourceHashes map[string][sha256.Size]byte
   rootFiles    []string
+
   // diskDigests is the published disk evidence for the current generation, kept
   // beside sourceHashes because the two answer different questions: one decides
   // whether to invalidate, the other is what the snapshot tells a consumer.
   diskDigests map[string]string
+
   // configDigests and roots are the build-universe fingerprint for the current
   // 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
+  configDigests []graph.FileDigest
+
   roots                   []graph.RootFile
   initialized             bool
   graphStore              *serveGraphStore
   requestProtocol         int
   requestProtocolSelected bool
+
   // pending remembers work the next request owes regardless of what the build
   // universe says: a generation whose state was captured but whose selected
   // projection failed, or an artifact set adopted after the graph carrying the
@@ -231,11 +242,9 @@ func newGraphSession(cwd, tsconfig string) (*graphSession, error) {
   return newGraphSessionWithArtifacts(cwd, tsconfig, nil)
 }
 
-// newGraphSessionWithArtifacts is the constructor the serve command uses, and
-// the plain one above is it with nothing published. The artifacts are read once
-// and held for the session: they are a second producer's facts about documents
-// this Program never read, so refreshing them is a different question from
-// refreshing the graph, and only the first answer is wired today.
+// newGraphSessionWithArtifacts loads one compiler session with the initial
+// artifact overlay. Requests can replace that overlay without reloading the
+// compiler because documents are not compiler inputs.
 func newGraphSessionWithArtifacts(
   cwd, tsconfig string,
   artifacts []graph.Artifact,
@@ -267,14 +276,6 @@ func (s *graphSession) adoptArtifacts(named *string) (bool, error) {
   if path == "" {
     return s.applyArtifacts(nil, withdrawnArtifactsDigest), nil
   }
-  stat, err := os.Stat(path)
-  if err != nil {
-    return false, err
-  }
-  state := artifactsFileState{size: stat.Size(), modTime: stat.ModTime().UnixNano()}
-  if path == s.artifactsFile && state == s.artifactsStat {
-    return false, nil
-  }
   // One read, hashed and decoded from the same bytes. Reading twice would let
   // an overwrite land between them and leave this session recording an identity
   // for a set it is not holding — after which a later request naming the file
@@ -283,27 +284,18 @@ func (s *graphSession) adoptArtifacts(named *string) (bool, error) {
   if err != nil {
     return false, err
   }
+  digest := sha256.Sum256(contents)
+  // Metadata alone cannot prove unchanged content. Comparing the applied
+  // digest also permits restoring the same file after an explicit withdrawal.
+  // Equivalent bytes reuse both decoding and graph projection.
+  if digest == s.artifactsDigest {
+    return false, nil
+  }
   next, err := graph.ParseArtifacts(contents)
   if err != nil {
     return false, err
   }
-  s.artifactsFile = path
-  s.artifactsStat = state
-  return s.applyArtifacts(next, sha256.Sum256(contents)), nil
-}
-
-// artifactsFileState is what an unchanged published file looks like from the
-// outside: size and modification time, never contents. It exists only to decide
-// whether the file is worth reading, and the digest taken from those contents is
-// still what decides whether the set is worth applying.
-type artifactsFileState struct {
-  size int64
-  // modTime is nanoseconds since the epoch rather than a time.Time, so the
-  // struct compares with == and means it. A time.Time carries a location
-  // pointer and an optional monotonic reading, and comparing two of those with
-  // == is a well-known way to get a false inequality that reads as a changed
-  // file forever.
-  modTime int64
+  return s.applyArtifacts(next, digest), nil
 }
 
 // applyArtifacts installs a set and reports whether it differs from the applied
@@ -354,6 +346,20 @@ func (s *graphSession) Close() error {
 }
 
 func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
+  prepared, mode, changed, err := s.prepareDumpSnapshot()
+  if err != nil || prepared == nil {
+    return nil, mode, changed, err
+  }
+  dump, err := prepared.publish(graph.GitIgnoredFiles(s.cwd, prepared.built))
+  if err != nil {
+    return nil, "", false, err
+  }
+  return dump, mode, true, nil
+}
+
+// prepareDumpSnapshot advances actual resident state and prepares its dump.
+// Completing it consumes evaluated membership and owns pending retry state.
+func (s *graphSession) prepareDumpSnapshot() (*preparedDumpProjection, string, bool, error) {
   change, err := s.nextChange(false)
   if err != nil {
     return nil, "", false, err
@@ -361,13 +367,18 @@ func (s *graphSession) Snapshot() (*graph.Dump, string, bool, error) {
   if change == nil {
     return nil, serveModeUnchanged, false, nil
   }
-  dump, err := s.buildDump()
-  if err != nil {
-    s.pending = change
-    return nil, "", false, err
+  prepared := s.prepareDumpProjection()
+  publish := prepared.publish
+  prepared.publish = func(ignored map[string]bool) (*graph.Dump, error) {
+    dump, err := publish(ignored)
+    if err != nil {
+      s.pending = change
+      return nil, err
+    }
+    s.pending = nil
+    return dump, nil
   }
-  s.pending = nil
-  return &dump, change.mode, true, nil
+  return prepared, change.mode, true, nil
 }
 
 type graphChange struct {
@@ -629,24 +640,30 @@ func missingRootInputs(configs []*shimtsoptions.ParsedCommandLine, sourceHashes
   return missing
 }
 
-func (s *graphSession) buildDump() (graph.Dump, error) {
+func (s *graphSession) prepareDumpProjection() *preparedDumpProjection {
   program := s.compiler.Program()
   built := graph.Build(program)
   graph.ApplyArtifacts(built, s.artifacts)
   // One texts map feeds both the spans and the manifest digests, so the bytes a
   // span points into are provably the bytes the manifest attests to.
   texts := graph.SourceTexts(program)
-  return graph.NewDump(
-    built,
-    s.cwd,
-    s.tsconfig,
-    graph.GitIgnoredFiles(s.cwd, built),
-    texts,
-    graph.DumpOrigin{
-      Provenance:  s.provenance(texts),
-      Diagnostics: graph.NewDiagnostics(program),
-    },
-  )
+  return &preparedDumpProjection{built: built, publish: func(ignored map[string]bool) (*graph.Dump, error) {
+    dump, err := graph.NewDump(
+      built,
+      s.cwd,
+      s.tsconfig,
+      ignored,
+      texts,
+      graph.DumpOrigin{
+        Provenance:  s.provenance(texts),
+        Diagnostics: graph.NewDiagnostics(program),
+      },
+    )
+    if err != nil {
+      return nil, err
+    }
+    return &dump, nil
+  }}
 }
 
 // serveProducer names this binary and the checker it links.
@@ -750,8 +767,9 @@ func invalidProjectError(diags []driver.Diagnostic) error {
 //
 // The first is the invalidation state: the hash the next snapshot compares
 // against to decide whether a file moved. It is deliberately not always the
-// file's disk hash — a file that raced the load is recorded under its resident
-// text so the comparison is guaranteed to miss and force a revisit.
+// file's disk hash. A file that raced the load receives a value different from
+// the observed disk hash, forcing a revisit even when disk bytes equal resident
+// text but the current preamble would change the next parsed source.
 //
 // The second is the source manifest's disk evidence: the hex digest of the bytes
 // actually read from disk, present only when the read succeeded. These are
@@ -790,13 +808,21 @@ func hashProgramSources(program *driver.Program) (map[string][sha256.Size]byte,
     // match what the checker holds. When they do not, the manifest's text and
     // disk digests disagree, which is precisely what a consumer needs to see.
     digests[source.FileName()] = graph.Digest(rawHash)
-    expected := driver.ApplySourcePreambleToFile(source.FileName(), string(content), program.SourcePreamble)
+    // Disk identity and checker text come from the same captured bytes. The
+    // compiler filesystem strips BOMs and decodes UTF-16 before parsing.
+    decoded, ok := shimvfs.DecodeBytes(string(content))
+    if !ok {
+      return nil, nil, fmt.Errorf("ttscgraph: decode %s", source.FileName())
+    }
+    expected := driver.ApplySourcePreambleToFile(source.FileName(), decoded, program.SourcePreamble)
     if source.Text() == expected {
       hashes[source.FileName()] = rawHash
     } else {
       // Force the next snapshot to revisit a file that changed while the
       // compiler session was loading instead of blessing mismatched disk text.
-      hashes[source.FileName()] = sha256.Sum256([]byte(source.Text()))
+      mismatchHash := rawHash
+      mismatchHash[0] ^= 0xff
+      hashes[source.FileName()] = mismatchHash
     }
   }
   return hashes, digests, nil
@@ -841,7 +867,12 @@ func changedSources(previous map[string][sha256.Size]byte) (map[string]string, b
       return nil, false, fmt.Errorf("ttscgraph: read %s: %w", path, err)
     }
     if sha256.Sum256(content) != oldHash {
-      changed[path] = string(content)
+      // Compiler overlays accept decoded text, not encoded filesystem bytes.
+      decoded, ok := shimvfs.DecodeBytes(string(content))
+      if !ok {
+        return nil, false, fmt.Errorf("ttscgraph: decode %s", path)
+      }
+      changed[path] = decoded
     }
   }
   return changed, false, nil
@@ -1078,15 +1109,21 @@ func serveSnapshots(input io.Reader, output io.Writer, cwd, tsconfig string) int
   return serveSnapshotsWithArtifacts(input, output, cwd, tsconfig, nil)
 }
 
-// serveSnapshotsWithArtifacts is the loop the serve command runs, and
-// serveSnapshots is it with nothing published — the shape every existing case
-// drives, unchanged.
+// serveSnapshotsWithArtifacts serves addressed JSON requests over one compiler
+// session. Its deferred close owns the session through EOF, protocol failure and
+// output failure; unsuccessful projections remain pending for a later request.
 func serveSnapshotsWithArtifacts(
   input io.Reader,
   output io.Writer,
   cwd, tsconfig string,
   artifacts []graph.Artifact,
 ) int {
+  return serveSnapshotRequests(input, output, cwd, tsconfig, artifacts, nativeSnapshotPublisher{})
+}
+
+// serveSnapshotRequests owns real NDJSON decoding, session lifetime and request
+// state. Publication uses its declared port; the default adapter acquires Git.
+func serveSnapshotRequests(input io.Reader, output io.Writer, cwd, tsconfig string, artifacts []graph.Artifact, publisher serveSnapshotPublisher) int {
   scanner := bufio.NewScanner(input)
   scanner.Buffer(make([]byte, 64*1024), 1024*1024)
   encoder := json.NewEncoder(output)
@@ -1185,9 +1222,9 @@ func serveSnapshotsWithArtifacts(
     var exportDuration time.Duration
     var err error
     if request.GraphSnapshotVersion == graphSnapshotProtocolVersion {
-      snapshot, mode, changed, semanticDuration, exportDuration, err = session.snapshotShardsWithTiming()
+      snapshot, mode, changed, semanticDuration, exportDuration, err = publisher.shards(session)
     } else {
-      dump, mode, changed, err = session.Snapshot()
+      dump, mode, changed, err = publisher.dump(session)
     }
     response := newServeResponse(request.ID)
     // The envelope answers for THIS session, not for the command in general. An

package/cmd/ttscgraph/serve_adopts_a_republished_artifact_set_test.go

@@ -13,29 +13,21 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/internal/graph"
 )
 
-// TestServeAdoptsARepublishedArtifactSet verifies a resident session replaces
-// its artifacts when the client republishes them, and does so without reloading
-// the compiler.
+// TestServeAdoptsARepublishedArtifactSet verifies replacing artifact inputs reprojects a resident graph.
 //
-// The artifacts describe documents the Program never read. That is deliberate —
-// it is what keeps editing a Markdown heading from costing a typecheck — but it
-// also means not one of the session's invalidation inputs moves when the
-// document does. Read once at startup, the set outlived every edit to it: a
-// developer who renamed a section watched the graph keep answering with the name
-// it used to have, for as long as the editor stayed open.
+// Artifact documents are outside the compiler source set. Their replacement
+// requires rebuild publication without a compiler input edit; omitting the field
+// and explicitly withdrawing the set must remain different requests.
 //
-// The mode is asserted, not merely the change. Reloading the Program would also
-// pick up the new set, and would also report `changed`; it would just pay a full
-// typecheck for a fact the compiler has no opinion about. `rebuild` is the
-// answer that reuses the resident Program and reprojects it, and it is the only
-// one that keeps the property this design exists for.
+// 1. Publish Pricing and repeat the same named set, requiring unchanged.
+// 2. Publish Discounts, requiring rebuild with the new node and no old node.
+// 3. Name a missing set and require an error without snapshot state.
+// 4. Explicitly withdraw artifacts and require their nodes and claim removed.
 //
-//  1. Publish one artifact set and take an initial snapshot naming it.
-//  2. Ask again naming the same file, and require `unchanged`.
-//  3. Publish a different set and ask again naming the new file.
-//  4. Require a `rebuild` carrying the new artifact and not the old one.
-//  5. Name a file that does not exist and require an error, not an empty graph.
-//  6. State the empty path and require the artifacts withdrawn.
+// @evidence contracts/testing.md#behavioral-verification Actual NDJSON requests retain an identical artifact set, replace it with rebuild publication, fail a missing named file without graph state and withdraw it on an explicit empty path.
+// @evidence contracts/testing.md#independent-expectations Literal pricing/discounts addresses define node membership; authored headings are fixture data, not separately asserted output. Unedited compiler sources and identical or replaced artifact bytes define unchanged and rebuild modes. A missing file requires an error without a dump; explicit withdrawal requires a real rebuild dump lacking the old node and the artifactNodes claim. These outcomes do not measure read/hash cost or compiler construction counts.
+// @evidence contracts/testing.md#distinguishing-cases Initial, repeated, republished, missing and empty-path requests contrast artifact identity, failure and withdrawal; absence of the artifacts field is owned by the startup-set case.
+// @evidence contracts/testing.md#execution-ownership TestServeAdoptsARepublishedArtifactSet is a Go source-unit entry. serveSnapshotRequests performs actual NDJSON decoding and resident lifecycle through the source publisher; prepared projection consumes explicit empty ignore membership. The owning operations stay in this test process, without installing a consumer or building or starting a native product binary. The separate worktree E2E owns real Git acquisition.
 func TestServeAdoptsARepublishedArtifactSet(t *testing.T) {
   root := graphSessionFixture(t)
   published := t.TempDir()
@@ -45,7 +37,7 @@ func TestServeAdoptsARepublishedArtifactSet(t *testing.T) {
   writeArtifactSet(t, second, "docs/sale.md#discounts", "Discounts")
 
   var output bytes.Buffer
-  code := serveSnapshotsWithArtifacts(
+  code := serveSourceSnapshotsWithArtifacts(
     bytes.NewReader([]byte(fmt.Sprintf(
       "{\"id\":1,\"artifacts\":%s}\n{\"id\":2,\"artifacts\":%s}\n{\"id\":3,\"artifacts\":%s}\n{\"id\":4,\"artifacts\":%s}\n{\"id\":5,\"artifacts\":%s}\n",
       mustJSONString(t, first),
@@ -80,10 +72,8 @@ func TestServeAdoptsARepublishedArtifactSet(t *testing.T) {
     t.Fatal("the initial dump does not carry the artifact its request named")
   }
 
-  // Naming the same file again must cost nothing. The client states the path on
-  // every request because only it can see the inputs behind the set; a server
-  // that treated the statement itself as news would reproject the whole graph
-  // on every single call.
+  // Identical artifact bytes must not cause another projection. Adoption still
+  // reads and hashes the named file; this mode assertion does not measure cost.
   if repeated.Mode != serveModeUnchanged || repeated.Changed || repeated.Dump != nil {
     t.Fatalf("restating the same artifact file was treated as a change: %#v", repeated)
   }
@@ -120,7 +110,7 @@ func TestServeAdoptsARepublishedArtifactSet(t *testing.T) {
   // project reaches by removing its plugin. Without it the only sayable things
   // are "here is a set" and "no opinion", and the removal would go on being
   // answered with the artifacts of a plugin that is gone.
-  if withdrawn.Mode != serveModeRebuild || !withdrawn.Changed {
+  if withdrawn.Mode != serveModeRebuild || !withdrawn.Changed || withdrawn.Dump == nil {
     t.Fatalf("withdrawing the artifacts answered %#v", withdrawn)
   }
   if dumpCarriesArtifact(withdrawn.Dump, "docs/sale.md#discounts") {
@@ -181,147 +171,6 @@ func dumpCarriesArtifact(dump any, address string) bool {
   return false
 }
 
-// TestServeKeepsAStartupSetAClientNeverMentions verifies that a request saying
-// nothing about artifacts leaves the ones the session started with alone.
-//
-// Three clients reach this path and none of them names a file: one built before
-// the field existed, one driving `ttscgraph serve --artifacts` by hand, and one
-// whose project publishes nothing but whose session was handed a set through
-// the flag. Reading their silence as "I have none" would empty the graph for
-// all three — and it is the same code path that must read an explicit empty
-// statement as exactly that, which is why the two are a pointer apart rather
-// than an empty string apart.
-//
-//  1. Start a session with an artifact set through the flag.
-//  2. Send two requests carrying no artifacts field at all.
-//  3. Require the set to survive both, and the capability to stay claimed.
-func TestServeKeepsAStartupSetAClientNeverMentions(t *testing.T) {
-  root := graphSessionFixture(t)
-
-  var output bytes.Buffer
-  code := serveSnapshotsWithArtifacts(
-    bytes.NewReader([]byte("{\"id\":1}\n{\"id\":2}\n")),
-    &output,
-    root,
-    "tsconfig.json",
-    []graph.Artifact{{
-      Address:  "docs/sale.md#pricing",
-      File:     "docs/sale.md",
-      Kind:     "markdown_section",
-      Line:     7,
-      Readable: "Pricing",
-    }},
-  )
-  if code != 0 {
-    t.Fatalf("serveSnapshotsWithArtifacts exited %d: %s", code, output.String())
-  }
-
-  decoder := json.NewDecoder(&output)
-  var initial serveResponse
-  var second serveResponse
-  if err := decoder.Decode(&initial); err != nil {
-    t.Fatal(err)
-  }
-  if err := decoder.Decode(&second); err != nil {
-    t.Fatal(err)
-  }
-  if !dumpCarriesArtifact(initial.Dump, "docs/sale.md#pricing") {
-    t.Fatalf("the startup set is absent from the initial dump: %#v", initial)
-  }
-  // The second request is where a silence-means-withdrawal reading would show:
-  // the first is the initial projection and carries the set either way.
-  if second.Mode != serveModeUnchanged || second.Changed {
-    t.Fatalf("a request naming no artifacts was treated as a change: %#v", second)
-  }
-  for _, response := range []serveResponse{initial, second} {
-    if !slices.Contains(response.Capabilities, string(graph.CapabilityArtifactNodes)) {
-      t.Fatalf("a session holding the startup set stopped claiming it: %v", response.Capabilities)
-    }
-  }
-}
-
-// TestServeAdoptsARepublishedSetOverTheShardProtocol verifies the refresh
-// reaches the protocol the product actually speaks.
-//
-// `@ttsc/graph` negotiates incremental shards on every request, so the
-// full-dump response the other cases drive is the compatibility path and not
-// the one a running editor uses. The two share one invalidation decision and
-// then diverge completely — different projection, different snapshot shape,
-// different assembly of what a client ends up holding — so a refresh proven on
-// one is not proven on the other.
-//
-//  1. Negotiate shards and take an initial snapshot naming one artifact set.
-//  2. Name a different set on the next request.
-//  3. Require a full shard snapshot carrying the new artifact and not the old.
-func TestServeAdoptsARepublishedSetOverTheShardProtocol(t *testing.T) {
-  root := t.TempDir()
-  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
-  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
-  "include": ["src"]
-}`)
-  // The declaration cites the artifact, so the edge to it lives in this
-  // source's own shard while the artifact node lands in the metadata shard.
-  // Both have to move together: a snapshot that replaced the artifact and left
-  // this shard alone would leave the client holding an edge into an address
-  // nothing publishes any more.
-  writeGraphFile(t, filepath.Join(root, "src", "index.ts"),
-    "/** @evidence docs/sale.md#pricing States the rule. */\nexport class Priced {}\n")
-  published := t.TempDir()
-  first := filepath.Join(published, "first.json")
-  second := filepath.Join(published, "second.json")
-  writeArtifactSet(t, first, "docs/sale.md#pricing", "Pricing")
-  writeArtifactSet(t, second, "docs/sale.md#discounts", "Discounts")
-
-  var output bytes.Buffer
-  code := serveSnapshotsWithArtifacts(
-    bytes.NewReader([]byte(fmt.Sprintf(
-      "{\"id\":1,\"graphSnapshotVersion\":%d,\"artifacts\":%s}\n{\"id\":2,\"graphSnapshotVersion\":%d,\"artifacts\":%s}\n",
-      graphSnapshotProtocolVersion,
-      mustJSONString(t, first),
-      graphSnapshotProtocolVersion,
-      mustJSONString(t, second),
-    ))),
-    &output,
-    root,
-    "tsconfig.json",
-    nil,
-  )
-  if code != 0 {
-    t.Fatalf("serveSnapshotsWithArtifacts exited %d: %s", code, output.String())
-  }
-
-  decoder := json.NewDecoder(&output)
-  var initial serveResponse
-  var republished serveResponse
-  if err := decoder.Decode(&initial); err != nil {
-    t.Fatal(err)
-  }
-  if err := decoder.Decode(&republished); err != nil {
-    t.Fatal(err)
-  }
-  if initial.Snapshot == nil {
-    t.Fatalf("the shard protocol was not negotiated: %#v", initial)
-  }
-  if !shardsCarryArtifact(initial.Snapshot, "docs/sale.md#pricing") {
-    t.Fatal("the initial shard snapshot does not carry the artifact its request named")
-  }
-  if republished.Mode != serveModeRebuild || republished.Snapshot == nil {
-    t.Fatalf("a republished set over the shard protocol answered %#v", republished)
-  }
-  if !shardsCarryArtifact(republished.Snapshot, "docs/sale.md#discounts") {
-    t.Fatal("the republished shard snapshot does not carry the artifact that replaced the old one")
-  }
-  if shardsCarryArtifact(republished.Snapshot, "docs/sale.md#pricing") {
-    t.Fatal("the republished shard snapshot still carries the withdrawn artifact")
-  }
-  // The citing source's shard has to come with it, whichever projection the
-  // session chose. Its edges name the address that just moved, so a client left
-  // holding the previous version of this shard holds a dangling one.
-  if !shardsCarrySource(republished.Snapshot, "src/index.ts") {
-    t.Fatal("the shard owning the citing declaration was not re-emitted, so its edge to the withdrawn address survives in the client")
-  }
-}
-
 // shardsCarrySource reports whether a shard for the named source was upserted.
 func shardsCarrySource(snapshot *serveGraphSnapshot, suffix string) bool {
   for _, upsert := range snapshot.Upserts {