ttsc 0.18.3 → 0.19.0

package/internal/graph/build.go

@@ -17,9 +17,11 @@ func Build(prog *driver.Program) *Graph {
   g := &Graph{
     Nodes:     map[string]*Node{},
     bodyNodes: map[string]bool{},
-    seen:      map[string]struct{}{},
+    seen:      map[edgeKey]struct{}{},
+    resolved:  map[*shimast.Node]*Target{},
   }
   for _, file := range prog.SourceFiles() {
+    g.putModuleNode(file)
     collectDeclarations(g, file)
   }
   g.addEdges(prog)
@@ -59,6 +61,24 @@ func collectStatements(g *Graph, path string, statements []*shimast.Node) {
     switch statement.Kind {
     case shimast.KindFunctionDeclaration:
       addNode(g, path, statement, NodeFunction)
+      // A function declared inside a function is still a name the runtime calls.
+      // This was off for a while on the theory that a closure is implementation,
+      // and implementation is read from the file — but Vue's renderer chain lives
+      // inside `baseCreateRenderer`, so `patch`, `mountElement` and
+      // `setupRenderEffect` were not implementation detail the index could skip;
+      // they were the flow the index exists to describe, and the graph had a blank
+      // where they belong. Asked how a state change reaches the DOM, a model spent
+      // three calls hunting for a name the graph did not hold.
+      //
+      // The cost is small and the answer is not bigger: the graph grows 3% in
+      // nodes on Vue and 5% on VS Code, and the tour payload does not change by a
+      // byte, because a closure ranks below the surface it hangs under and never
+      // takes a seed. It answers when asked for by name. Measured on the
+      // specific-flow lane: 59% of baseline tokens saved to 82%, and the calls
+      // halve — TypeORM 5 to 1, VS Code 8 to 2, Vue 6 to 2.
+      //
+      // The bodies stay out. A closure is a node with edges, not source text.
+      collectClosures(g, path, statement)
     case shimast.KindClassDeclaration:
       addNode(g, path, statement, NodeClass)
       collectMembers(g, path, statement)
@@ -81,7 +101,8 @@ func collectStatements(g *Graph, path string, statements []*shimast.Node) {
 }
 
 // collectVariables records a variable node for each binding in a top-level
-// variable statement (both bindings of `const a = 1, b = 2`).
+// variable statement (both bindings of `const a = 1, b = 2`), then the functions
+// declared inside a binding that holds one.
 func collectVariables(g *Graph, path string, statement *shimast.Node) {
   variables := statement.AsVariableStatement()
   if variables == nil || variables.DeclarationList == nil {
@@ -93,9 +114,248 @@ func collectVariables(g *Graph, path string, statement *shimast.Node) {
   }
   for _, binding := range list.Declarations.Nodes {
     addNode(g, path, binding, NodeVariable)
+    collectClosures(g, path, binding)
   }
 }
 
+// collectClosures records a node for each function a declaration's body declares,
+// and for the functions those declare in turn.
+//
+// A factory that closes over its state and returns local functions is how much of
+// the ecosystem writes its engine: Vue's `patch`, `mountElement`, and
+// `setupRenderEffect` are locals of `baseCreateRenderer`; a curried validator's
+// real parse is a local of the function that binds its error class. Recording only
+// what a file declares at its top level left that code out of the graph entirely —
+// a model asking how a state change reaches the DOM found the factory, nothing
+// under it, and went to read the files.
+//
+// Only functions are recorded. A local `const i = 0` is a value, not a place code
+// runs, and the graph would drown in them.
+func collectClosures(g *Graph, path string, declaration *shimast.Node) {
+  for _, closure := range ClosuresIn(declaration) {
+    name, ok := ClosureName(closure)
+    if !ok {
+      continue
+    }
+    kind := NodeFunction
+    if closure.Kind == shimast.KindVariableDeclaration {
+      kind = NodeVariable
+    }
+    putDeclaredNode(g, path, name, kind, closure)
+    if node, ok := g.Nodes[nodeID(path, name, kind)]; ok {
+      node.Closure = true
+    }
+    collectClosures(g, path, closure)
+  }
+}
+
+// ClosureName returns the name a closure is recorded under — its own name behind
+// the names of the functions it is nested in, so `baseCreateRenderer.patch` and
+// another file-mate's `patch` are two nodes rather than one merged phantom.
+//
+// It reports false when any enclosing function is anonymous. An `inner` declared
+// inside two different callbacks of one file would otherwise key the same id and
+// merge into a node that is neither, fabricating edges between unrelated scopes.
+// Such a closure stays out of the graph, exactly as every body-scoped declaration
+// did before.
+func ClosureName(closure *shimast.Node) (string, bool) {
+  symbol := closure.Symbol()
+  if symbol == nil {
+    return "", false
+  }
+  name := qualifiedName(symbol)
+  if name == "" {
+    return "", false
+  }
+  for parent := closure.Parent; parent != nil; parent = parent.Parent {
+    if parent.Kind == shimast.KindSourceFile {
+      break
+    }
+    if !isFunctionLike(parent) {
+      continue
+    }
+    owner, ok := ownerName(parent)
+    if !ok {
+      return "", false
+    }
+    name = owner + "." + name
+  }
+  return name, true
+}
+
+// isFunctionLike reports whether a node is a function whose body is a scope. A
+// variable that binds one is not: the function it holds is a node of this chain
+// already, and counting both would name a closure after its owner twice.
+func isFunctionLike(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindConstructor,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor:
+    return true
+  }
+  return false
+}
+
+// ownerName returns the name of a function-like declaration a closure sits in: a
+// function or method by its own (class-qualified) name, a function expression or
+// arrow by the variable that binds it. It reports false for an anonymous one.
+func ownerName(declaration *shimast.Node) (string, bool) {
+  switch declaration.Kind {
+  case shimast.KindFunctionExpression, shimast.KindArrowFunction:
+    binding := bindingOf(declaration)
+    if binding == nil {
+      return "", false
+    }
+    declaration = binding
+  }
+  symbol := declaration.Symbol()
+  if symbol == nil {
+    return "", false
+  }
+  name := qualifiedName(symbol)
+  if name == "" {
+    return "", false
+  }
+  return name, true
+}
+
+// bindingOf returns the variable declaration a function expression is bound to,
+// seeing through the wrappers a codebase writes around one, or nil when the
+// function is anonymous.
+func bindingOf(fn *shimast.Node) *shimast.Node {
+  for parent := fn.Parent; parent != nil; parent = parent.Parent {
+    switch parent.Kind {
+    case shimast.KindVariableDeclaration:
+      return parent
+    case shimast.KindAsExpression,
+      shimast.KindSatisfiesExpression,
+      shimast.KindParenthesizedExpression:
+      continue
+    default:
+      return nil
+    }
+  }
+  return nil
+}
+
+// ClosuresIn returns the functions a declaration's body declares — a nested
+// function declaration, or a binding that holds a function — found however deep
+// in the body's statements they sit (inside an `if`, a `try`, a loop), but not
+// past one: a closure's own closures belong to it, and the caller recurses.
+//
+// A binding that holds no function is not one. A local `const i = 0` is a value,
+// not a place code runs.
+func ClosuresIn(declaration *shimast.Node) []*shimast.Node {
+  body := functionBody(declaration)
+  if body == nil {
+    return nil
+  }
+  var closures []*shimast.Node
+  var walk func(node *shimast.Node)
+  walk = func(node *shimast.Node) {
+    node.ForEachChild(func(child *shimast.Node) bool {
+      if IsClosure(child) {
+        closures = append(closures, child)
+        return false
+      }
+      walk(child)
+      return false
+    })
+  }
+  walk(body)
+  return closures
+}
+
+// IsClosure reports whether a node inside a function body is a function the graph
+// records: a nested function declaration, or a binding that holds a function.
+func IsClosure(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    return true
+  case shimast.KindVariableDeclaration:
+    return functionBody(node) != nil
+  }
+  return false
+}
+
+// functionBody returns the block body of any function-like declaration — a
+// function, a method, an accessor, a constructor, or a function/arrow expression
+// a variable binds.
+func functionBody(declaration *shimast.Node) *shimast.Node {
+  switch declaration.Kind {
+  case shimast.KindFunctionDeclaration:
+    if fn := declaration.AsFunctionDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindFunctionExpression:
+    if fn := declaration.AsFunctionExpression(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindArrowFunction:
+    if fn := declaration.AsArrowFunction(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindMethodDeclaration:
+    if fn := declaration.AsMethodDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindConstructor:
+    if fn := declaration.AsConstructorDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindGetAccessor:
+    if fn := declaration.AsGetAccessorDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindSetAccessor:
+    if fn := declaration.AsSetAccessorDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindVariableDeclaration:
+    if binding := declaration.AsVariableDeclaration(); binding != nil {
+      return functionBodyOfInitializer(binding.Initializer)
+    }
+  }
+  return nil
+}
+
+// functionBodyOfInitializer unwraps a binding's initializer to the body of the
+// function it holds, seeing through the `as const` / satisfies wrappers a
+// codebase writes around one.
+func functionBodyOfInitializer(initializer *shimast.Node) *shimast.Node {
+  for initializer != nil {
+    switch initializer.Kind {
+    case shimast.KindFunctionExpression, shimast.KindArrowFunction:
+      return functionBody(initializer)
+    case shimast.KindAsExpression:
+      as := initializer.AsAsExpression()
+      if as == nil {
+        return nil
+      }
+      initializer = as.Expression
+    case shimast.KindSatisfiesExpression:
+      satisfies := initializer.AsSatisfiesExpression()
+      if satisfies == nil {
+        return nil
+      }
+      initializer = satisfies.Expression
+    case shimast.KindParenthesizedExpression:
+      parenthesized := initializer.AsParenthesizedExpression()
+      if parenthesized == nil {
+        return nil
+      }
+      initializer = parenthesized.Expression
+    default:
+      return nil
+    }
+  }
+  return nil
+}
+
 // addNode records a node for the symbol declared by node under its
 // position-invariant id. A declaration the checker did not bind to a single
 // named symbol (a destructuring pattern) is skipped. Redeclarations keep the
@@ -125,6 +385,7 @@ func collectMembers(g *Graph, path string, statement *shimast.Node) {
     case isPropertyMember(member.Kind):
       putDeclaredNode(g, path, name, NodeVariable, member)
     }
+    collectClosures(g, path, member)
   }
 }
 
@@ -253,7 +514,40 @@ func simpleName(symbol *shimast.Symbol) string {
   if symbol == nil || symbol.Name == "" {
     return ""
   }
-  return strings.ReplaceAll(symbol.Name, "\xFE", "__")
+  return stripPrivateMangling(strings.ReplaceAll(symbol.Name, "\xFE", "__"))
+}
+
+// stripPrivateMangling removes the checker's per-run counter from the name of a
+// private class member.
+//
+// A `#field` is bound under a mangled name — `__#41@#field` — whose number comes
+// from a counter that advances as the program is bound, so the same field is
+// `__#41@#field` in one run and `__#38@#field` in the next. That counter reached
+// the node id, and with it the wire: on VS Code, 661 nodes and 661 edges changed
+// identity between two dumps of the *same unedited source*. A handle the model
+// was given could name nothing after a restart, and no dump could be compared to
+// another to prove a change had left the facts alone.
+//
+// The number identifies nothing a reader can use — the class already
+// distinguishes the field, and `#field` is what the source calls it. Dropping it
+// makes the id a function of the code again.
+func stripPrivateMangling(name string) string {
+  const prefix = "__#"
+  start := strings.Index(name, prefix)
+  if start == -1 {
+    return name
+  }
+  rest := name[start+len(prefix):]
+  at := strings.IndexByte(rest, '@')
+  if at <= 0 {
+    return name
+  }
+  for _, char := range rest[:at] {
+    if char < '0' || char > '9' {
+      return name
+    }
+  }
+  return name[:start] + rest[at+1:]
 }
 
 // qualifiedName is the identity name of a symbol: its own name, prefixed by the

package/internal/graph/build_records_a_node_per_top_level_declaration_test.go

@@ -68,8 +68,10 @@ export const value = 1;
     "En":    NodeEnum,
     "value": NodeVariable,
   }
-  if len(graph.Nodes) != len(want) {
-    t.Fatalf("expected %d nodes, got %d: %v", len(want), len(graph.Nodes), nodeIDSet(graph))
+  // The module node is the file's export surface, not a declaration in it, so
+  // the declaration count excludes it.
+  if declared := declaredNodeCount(graph); declared != len(want) {
+    t.Fatalf("expected %d nodes, got %d: %v", len(want), declared, nodeIDSet(graph))
   }
   for name, kind := range want {
     id := nodeID(path, name, kind)
@@ -86,6 +88,18 @@ export const value = 1;
   }
 }
 
+// declaredNodeCount counts the nodes that stand for a declaration, leaving out
+// the module node a file's export table adds.
+func declaredNodeCount(graph *Graph) int {
+  count := 0
+  for _, node := range graph.Nodes {
+    if node.Kind != NodeModule {
+      count++
+    }
+  }
+  return count
+}
+
 // nodeIDSet returns the graph's node ids as a slice for failure messages.
 func nodeIDSet(graph *Graph) []string {
   ids := make([]string, 0, len(graph.Nodes))

package/internal/graph/diagnostics.go

@@ -8,10 +8,11 @@ import "github.com/samchon/ttsc/packages/ttsc/driver"
 // over the warm checker, not a second compile.
 //
 // This is the compiler-only slice: it carries the TypeScript semantic
-// diagnostics, not @ttsc/lint or transform-plugin findings. The MCP server fuses
-// those onto the graph separately, through diagnostic providers the launcher
-// feeds (see mcp.DiagnosticProvider). This helper and its tests pin the
-// compiler-diagnostic conversion (code, column, message) on its own.
+// diagnostics, not @ttsc/lint or transform-plugin findings. Nothing in the
+// graph pipeline calls it yet; the dump and MCP results carry no diagnostics.
+// This helper and its tests pin the compiler-diagnostic conversion (code,
+// column, message) so a future diagnostics integration starts from a proven
+// producer.
 func FileDiagnostics(prog *driver.Program, path string) []driver.Diagnostic {
   out := make([]driver.Diagnostic, 0)
   for _, diagnostic := range prog.Diagnostics() {

package/internal/graph/dump.go

@@ -1,7 +1,9 @@
 package graph
 
 import (
+  "bufio"
   "encoding/json"
+  "io"
   "path/filepath"
   "sort"
   "strings"
@@ -27,8 +29,15 @@ import (
 
 // DumpEvidence is a 1-based source span grounding a node declaration or an edge
 // expression. It is display/expansion only, never identity.
+//
+// File is omitted when the reader reconstructs it exactly: a node's span is in
+// the node's file, and an edge's span is in the file its `from` id names. The
+// path is long, it rode the wire once per node and once per edge, and on VS Code
+// those two copies are 55 MB of a 323 MB document that then has to be encoded,
+// piped, parsed and validated. An `implementation` span keeps its file — that one
+// can genuinely live in another file from the declaration that owns it.
 type DumpEvidence struct {
-  File      string `json:"file"`
+  File      string `json:"file,omitempty"`
   StartLine int    `json:"startLine"`
   StartCol  int    `json:"startCol,omitempty"`
   EndLine   int    `json:"endLine,omitempty"`
@@ -59,6 +68,7 @@ type DumpNode struct {
   External       bool            `json:"external"`
   Ignored        bool            `json:"ignored,omitempty"`
   Exported       bool            `json:"exported,omitempty"`
+  Closure        bool            `json:"closure,omitempty"`
   Modifiers      []string        `json:"modifiers,omitempty"`
   Evidence       *DumpEvidence   `json:"evidence,omitempty"`
   Implementation *DumpEvidence   `json:"implementation,omitempty"`
@@ -108,6 +118,11 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
   nodes := make([]DumpNode, 0, len(g.Nodes))
   for _, n := range g.Nodes {
     name, qualified := nodeNames(n)
+    // A module is named by its file, so its name relativizes like a path; every
+    // other node is named by a symbol.
+    if n.Kind == NodeModule {
+      name, qualified = ctx.rel(name), ""
+    }
     nodes = append(nodes, DumpNode{
       ID:             ctx.relID(n.ID),
       Kind:           string(n.Kind),
@@ -117,8 +132,9 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
       External:       n.External,
       Ignored:        ignored[n.File],
       Exported:       n.Exported,
+      Closure:        n.Closure,
       Modifiers:      n.Modifiers,
-      Evidence:       ctx.evidence(n.File, n.Pos, n.End),
+      Evidence:       withoutFile(ctx.evidence(n.File, n.Pos, n.End)),
       Implementation: ctx.evidence(n.ImplementationFile, n.ImplementationPos, n.ImplementationEnd),
       Decorators:     decByNode[n.ID],
     })
@@ -131,7 +147,7 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
       From:     ctx.relID(e.From),
       To:       ctx.relID(e.To),
       Kind:     dumpEdgeKind(e),
-      Evidence: ctx.edgeEvidence(e),
+      Evidence: withoutFile(ctx.edgeEvidence(e)),
     })
   }
   sort.Slice(edges, func(i, j int) bool {
@@ -162,6 +178,26 @@ func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, so
   return json.Marshal(d)
 }
 
+// EncodeDump writes the export JSON straight to w, one buffered pass, ending it
+// with the newline the one-shot protocol expects.
+//
+// The alternative is what the dump command used to do: marshal the whole
+// document into a byte slice, convert that slice into a string, and print the
+// string. On VS Code the document is 323 MB, so the conversion was a second full
+// copy of it held live beside the first — half a gigabyte of peak heap that
+// bought nothing, because the bytes were already exactly what stdout wanted.
+func EncodeDump(w io.Writer, g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, pretty bool) error {
+  buffered := bufio.NewWriterSize(w, 1<<20)
+  encoder := json.NewEncoder(buffered)
+  if pretty {
+    encoder.SetIndent("", "  ")
+  }
+  if err := encoder.Encode(NewDump(g, project, tsconfig, ignored, sources)); err != nil {
+    return err
+  }
+  return buffered.Flush()
+}
+
 // dumpEdgeKind maps an internal edge kind, refined by Edge.Origin, onto the
 // schema's finer relationship kind.
 func dumpEdgeKind(e *Edge) string {
@@ -256,12 +292,22 @@ func (c *dumpContext) rel(file string) string {
 
 // relID relativizes the path portion of a node id ("path#qualifiedName:kind").
 // An id with no path (a future virtual node) is returned unchanged.
+//
+// A module is named by its own file path, so both halves of its id are paths and
+// both relativize. Every other node is named by a symbol, which passes through
+// untouched.
 func (c *dumpContext) relID(id string) string {
   hash := strings.Index(id, "#")
   if hash < 0 {
     return id
   }
-  return c.rel(id[:hash]) + id[hash:]
+  head, tail := c.rel(id[:hash]), id[hash+1:]
+  suffix := ":" + string(NodeModule)
+  if strings.HasSuffix(tail, suffix) {
+    name := strings.TrimSuffix(tail, suffix)
+    return head + "#" + c.rel(name) + suffix
+  }
+  return head + "#" + tail
 }
 
 // evidence builds the line/col span for a byte range in file, or nil when the
@@ -337,6 +383,16 @@ func (c *dumpContext) edgeEvidence(e *Edge) *DumpEvidence {
   return c.evidence(file, e.Pos, e.End)
 }
 
+// withoutFile drops a span file the reader reconstructs from the node or edge
+// that carries the span. It never touches an implementation span.
+func withoutFile(ev *DumpEvidence) *DumpEvidence {
+  if ev == nil {
+    return nil
+  }
+  ev.File = ""
+  return ev
+}
+
 // nodeFile recovers the source file path embedded in a node id
 // ("path#qualifiedName:kind"); "" for an id without a path.
 func nodeFile(id string) string {

package/internal/graph/dump_is_a_function_of_the_source_test.go

@@ -0,0 +1,71 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestDumpIsAFunctionOfTheSource pins the graph to the code it describes: two
+// builds of one unedited snapshot must produce one byte-identical document.
+//
+// It did not. A private class member — `#count` — is bound under a mangled name
+// carrying a counter that advances as the program is bound: `__#41@#count` in one
+// run, `__#38@#count` in the next. That counter reached the node id, and with it
+// the wire. On VS Code, 661 nodes and 661 edges changed identity between two
+// dumps of the *same source*: a handle the model was given could name nothing
+// after a restart, and no dump could be compared with another to prove that a
+// change had left the facts alone — the byte test every graph optimisation is
+// supposed to answer to was itself meaningless.
+//
+// Two classes each declare a `#count`, so the mangling counter is exercised more
+// than once and a per-class collision would surface here rather than in a
+// three-million-line repository.
+func TestDumpIsAFunctionOfTheSource(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Counter {
+  #count = 0;
+  #step: number;
+  constructor(step: number) {
+    this.#step = step;
+  }
+  bump(): number {
+    this.#count += this.#step;
+    return this.#count;
+  }
+}
+
+export class Other {
+  #count = 0;
+  read(): number {
+    return this.#count;
+  }
+}
+`)
+
+  first := dumpBytes(t, root)
+  second := dumpBytes(t, root)
+  if string(first) != string(second) {
+    t.Fatalf("two dumps of one unedited snapshot differ: the graph is not a function of the source")
+  }
+}
+
+func dumpBytes(t *testing.T, root string) []byte {
+  t.Helper()
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  data, err := MarshalDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), false)
+  if err != nil {
+    t.Fatalf("MarshalDump: %v", err)
+  }
+  return data
+}

package/internal/graph/dump_serializes_the_full_graph_test.go

@@ -102,8 +102,18 @@ export function main(): void {
   if call == nil {
     t.Fatalf("no calls edge main -> helper in dump:\n%s", data)
   }
-  if call.Evidence == nil || call.Evidence.StartLine == 0 || call.Evidence.File != "src/main.ts" {
-    t.Fatalf("call edge missing project-relative line/col evidence: %+v", call.Evidence)
+  // The edge's span carries no file: it is the file its `from` id names, which
+  // the loader reconstructs (see ITtscGraphDump.IEdge). Sending the path a
+  // second time on every edge is 17% of the document for a value the reader
+  // already holds.
+  if call.Evidence == nil || call.Evidence.StartLine == 0 {
+    t.Fatalf("call edge missing line/col evidence: %+v", call.Evidence)
+  }
+  if call.Evidence.File != "" {
+    t.Fatalf("call edge repeats the file its `from` id already names: %+v", call.Evidence)
+  }
+  if nodeFile(call.From) != "src/main.ts" {
+    t.Fatalf("the edge's file is not recoverable from its from id: %q", call.From)
   }
 
   // Every edge endpoint resolves to a dumped node.
@@ -129,8 +139,10 @@ export function main(): void {
     }
   }
   // The dump carries no ceremony keys: it is wholly checker-resolved, so it has
-  // no per-edge trust flags and no schema version to negotiate.
-  for _, gone := range []string{`"schemaVersion"`, `"provenance":`, `"confidence":`, `"text":`} {
+  // no per-edge trust flags and no schema version to negotiate. It also carries
+  // no keys the schema stopped promising: no inlined evidence text and no
+  // diagnostics array.
+  for _, gone := range []string{`"schemaVersion"`, `"provenance":`, `"confidence":`, `"text":`, `"diagnostics":`} {
     if strings.Contains(s, gone) {
       t.Fatalf("dump still emits removed key %s:\n%s", gone, s)
     }