ttsc 0.27.0 → 0.28.1

package/driver/emit_plugin.go

@@ -96,13 +96,30 @@ func (p *Program) EmitLinkedTransforms(writeFile shimcompiler.WriteFile) ([]Diag
 // because the emit context's update hook only records the original, it does not
 // copy `DeclarationBase.Symbol`.
 //
-// tsgo's emit resolver then walks the transformed tree in
-// MarkLinkedReferencesRecursively and, when it resolves an identifier whose
-// scope chain passes through one of those rebuilt containers, calls
-// getSymbolOfDeclaration(container) — which reads container.Symbol() and nil-
-// panics on a rebuilt class/interface/enum. Restoring the symbol from the
-// original (the symbol object is shared and node-independent for lookup) lets
-// the resolver mark references the same way it would on the parse tree.
+// #201 added this against a real panic in the walk that
+// MarkLinkedReferencesRecursively used to run over the transformed tree. That
+// walk no longer happens here — the builtin chain is built from the parse tree
+// below — so the original trigger is gone, and no probe reproduces a panic with
+// this call stubbed out.
+//
+// Keep it anyway, because the remaining exposure is unproven rather than
+// absent. tsgo's own defense against a plugin-built node is ast.IsParseTreeNode,
+// which most EmitResolver reference methods test to bail out early — and a
+// REBUILT container does not trip it. The emit context stamps
+// NodeFlagsSynthesized when its factory creates a node, but ast.updateNode then
+// ASSIGNS `updated.Flags = original.Flags` and clears the marker again, so a
+// container carrying no symbol still answers "parse tree node" and is let
+// through to checker name resolution. There resolveName reaches
+// getSymbolOfDeclaration(container), an unguarded dereference for a class,
+// class expression, or interface (enum and module are nil-checked upstream).
+// What the probes could not settle is whether the builtin transformers ever
+// actually hand a rebuilt container to one of those methods.
+//
+// Restoring the symbol from the original (the symbol object is shared and
+// node-independent for lookup) makes that path resolve the way it would on the
+// parse tree, at the cost of one walk per file. EmitContext.ParseNode is
+// unaffected either way: it walks MostOriginal before testing the predicate, so
+// it always lands on the genuine parse node.
 func restoreOriginalDeclarationSymbols(ec *shimprinter.EmitContext, node *shimast.Node) {
   if node == nil {
     return
@@ -180,7 +197,39 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       }
       shimast.SetParentInChildrenUnset(out.AsNode())
       restoreOriginalDeclarationSymbols(ec, out.AsNode())
-      for _, tr := range shimcompiler.GetScriptTransformers(ec, host, out) {
+      // Build the chain from the PARSE tree and transform the plugin's tree.
+      // Upstream passes one file to both roles only because it has no plugin
+      // pass between them: emitJSFile hands getScriptTransformers the file it
+      // parsed, then reassigns it to the transform result. Here they differ.
+      //
+      // getScriptTransformers reads its file for three things: in-JS-file, JSX
+      // language variant, and emitResolver.MarkLinkedReferencesRecursively. The
+      // first two survive UpdateSourceFile, so marking is the whole difference,
+      // and marking is a per-node checker resolution walk under the single
+      // checker mutex.
+      //
+      // Marking the plugin's tree does not merely spend that walk on nodes the
+      // binder never saw, it emits broken JavaScript. Elision reads the marks
+      // back for the file's parse-tree imports, so a reference the plugin
+      // REBUILT (a fresh identifier linked with SetOriginal, which is what any
+      // partial rewrite produces) leaves its import unmarked. The module
+      // transform still aliases that reference and elision still drops the
+      // binding the alias names: `dep_1.foo` with no `const dep_1 =
+      // require(...)`, a ReferenceError at load. The emit_plugin_rebuilt_*
+      // tests pin each import binding shape, plus the ES module lane where the
+      // whole import declaration disappears instead of just its binding.
+      //
+      // Nothing is lost by skipping the plugin's nodes. UpdateSourceFile
+      // rebuilds a SourceFile through copyFrom, which carries over neither
+      // Locals nor Symbol, and an ordinary import binds into Locals, so no
+      // resolveName branch reaches an import from a synthetic identifier. An
+      // import the plugin synthesized needs no mark at all: it has no parse
+      // original, and elision preserves it unconditionally.
+      //
+      // Marks accumulate on the checker and are never cleared, so marking one
+      // fixed tree per file also stops a second emit on the same Program from
+      // inheriting the first pass's plugin-tree marks.
+      for _, tr := range shimcompiler.GetScriptTransformers(ec, host, sf) {
         out = tr.TransformSourceFile(out)
       }
       // Print through the source-map-aware helper so a `sourceMap` /

package/driver/plugins.go

@@ -106,6 +106,10 @@ type PluginContext struct {
   reportHostInputHashUnknown     func(string)
   reportHostInputRealpath        func(string, *string)
   reportHostInputRealpathUnknown func(string)
+  reportFileDependency           func(string, string)
+  reportFileDependencyRejected   func(string)
+  reportFileComplete             func(string)
+  reportEveryFileComplete        func()
 }
 
 // ReportHostInputHash declares the exact file state consumed by a native
@@ -186,6 +190,94 @@ func (ctx PluginContext) ReportHostInput(file string) {
   ctx.reportHostInput(filepath.Clean(file))
 }
 
+// ReportFileDependency declares one file whose content influenced this
+// plugin's contribution to the transformed file file. Both are resolved
+// against the plugin's cwd and keyed like every other envelope section, so a
+// plugin reports the program's own file names and the host joins the sections
+// by key.
+//
+// Reporting alone only widens what a consumer invalidates on; it is
+// ReportFileDependenciesComplete that turns the reported set into the file's
+// whole input set.
+//
+// A dependency this cannot resolve to a key is not silently forgotten: it
+// withdraws this plugin's completeness claim for that file, because a complete
+// list missing a member is exactly what serves stale output. The plugin's other
+// files keep theirs.
+func (ctx PluginContext) ReportFileDependency(file string, dependency string) {
+  if ctx.reportFileDependency == nil {
+    return
+  }
+  target, ok := ctx.transformKey(file)
+  if !ok {
+    return
+  }
+  input, ok := ctx.transformKey(dependency)
+  if !ok {
+    if ctx.reportFileDependencyRejected != nil {
+      ctx.reportFileDependencyRejected(target)
+    }
+    return
+  }
+  ctx.reportFileDependency(target, input)
+}
+
+// ReportFileDependenciesComplete declares that everything this plugin's
+// contribution to file consumed, beyond file's own text and the universal
+// compiler-option chain, was reported through ReportFileDependency — possibly
+// nothing at all.
+//
+// The declaration is per (plugin, file), the way the protocol's completeness
+// contract defines it: the host lists a file in dependenciesComplete only when
+// every plugin that can contribute to it declared it, because a consumer cannot
+// attribute one plugin's entries back to it.
+func (ctx PluginContext) ReportFileDependenciesComplete(file string) {
+  if ctx.reportFileComplete == nil {
+    return
+  }
+  target, ok := ctx.transformKey(file)
+  if !ok {
+    return
+  }
+  ctx.reportFileComplete(target)
+}
+
+// ReportDependenciesComplete makes the same declaration for every file in the
+// program at once: this plugin's contribution to any transformed file is a
+// function of that file's own text, whatever it reported for that file, its
+// reported host inputs, and the compiler options.
+//
+// That is the honest claim of a syntactic transform — one that decides from the
+// file in front of it and its own configuration rather than from the type
+// system — and it is the only form available to a hook that never sees the
+// program, such as SourcePreamble.
+func (ctx PluginContext) ReportDependenciesComplete() {
+  if ctx.reportEveryFileComplete == nil {
+    return
+  }
+  ctx.reportEveryFileComplete()
+}
+
+// transformKey resolves one plugin-reported path to the key convention every
+// envelope section uses. A plugin reports the spellings its host handed it
+// (absolute program file names, or paths relative to the plugin's cwd), and
+// the compiler's own file names are slash-normalized on every platform, so
+// both sides must pass through TransformOutputKey to meet.
+//
+// Separators and the project prefix reconcile, but the suffix keeps the case
+// the caller wrote: report the program's own spelling of a file rather than a
+// re-cased one, or the key will not match on a case-insensitive filesystem and
+// the declaration is dropped.
+func (ctx PluginContext) transformKey(file string) (string, bool) {
+  if strings.TrimSpace(file) == "" {
+    return "", false
+  }
+  if !filepath.IsAbs(file) {
+    file = filepath.Join(ctx.Cwd, file)
+  }
+  return TransformOutputKey(ctx.Cwd, filepath.Clean(file)), true
+}
+
 // SourcePreamblePlugin can inject source text before TypeScript-Go parses the
 // project. This is intentionally generic: the driver knows only the registered
 // plugin name and the project plugin manifest.
@@ -214,10 +306,11 @@ type EmitTransformPlugin interface {
 }
 
 type linkedPluginState struct {
-  cwd      string
-  entries  []PluginEntry
-  inputs   *pluginHostInputScopes
-  tsconfig string
+  cwd          string
+  declarations *pluginFileDeclarations
+  entries      []PluginEntry
+  inputs       *pluginHostInputScopes
+  tsconfig     string
 }
 
 // pluginHostInputScopes keeps one observation set per plugin hook. A hash from
@@ -472,17 +565,23 @@ func RegisterPlugin(plugin any) {
 func loadLinkedPluginState(cwd, tsconfigPath string) (linkedPluginState, error) {
   input := strings.TrimSpace(os.Getenv(LinkedPluginsEnv))
   if input == "" {
-    return linkedPluginState{cwd: cwd, inputs: newPluginHostInputScopes(), tsconfig: tsconfigPath}, nil
+    return linkedPluginState{
+      cwd:          cwd,
+      declarations: newPluginFileDeclarations(),
+      inputs:       newPluginHostInputScopes(),
+      tsconfig:     tsconfigPath,
+    }, nil
   }
   var entries []PluginEntry
   if err := json.Unmarshal([]byte(input), &entries); err != nil {
     return linkedPluginState{}, fmt.Errorf("ttsc driver: invalid %s: %w", LinkedPluginsEnv, err)
   }
   return linkedPluginState{
-    cwd:      cwd,
-    entries:  entries,
-    inputs:   newPluginHostInputScopes(),
-    tsconfig: tsconfigPath,
+    cwd:          cwd,
+    declarations: newPluginFileDeclarations(),
+    entries:      entries,
+    inputs:       newPluginHostInputScopes(),
+    tsconfig:     tsconfigPath,
   }, nil
 }
 
@@ -500,7 +599,7 @@ func (state linkedPluginState) sourcePreamble() (string, error) {
     if !ok {
       continue
     }
-    text, err := preamble.SourcePreamble(state.context(entry))
+    text, err := preamble.SourcePreamble(state.contextAt(index, entry))
     if err != nil {
       return "", err
     }
@@ -521,7 +620,7 @@ func (state linkedPluginState) apply(prog *Program) error {
     if !ok {
       continue
     }
-    if err := transform.ApplyProgram(prog, state.context(entry)); err != nil {
+    if err := transform.ApplyProgram(prog, state.contextAt(index, entry)); err != nil {
       return err
     }
   }
@@ -555,7 +654,7 @@ func (state linkedPluginState) emitTransforms() ([]PluginTransform, error) {
     if !ok {
       continue
     }
-    transform, err := emitter.EmitTransform(state.context(entry))
+    transform, err := emitter.EmitTransform(state.contextAt(index, entry))
     if err != nil {
       return nil, err
     }
@@ -576,9 +675,17 @@ func registeredPlugin(index int) (any, bool) {
   return pluginRegistry[index], true
 }
 
-// context builds the PluginContext the driver passes to each plugin hook.
-func (state linkedPluginState) context(entry PluginEntry) PluginContext {
+// contextAt builds the PluginContext the driver passes to one plugin hook.
+//
+// Host-input observations are scoped per hook, because a hash one hook reported
+// cannot prove another hook's dependency on the same path. Dependency
+// declarations are scoped per plugin instead: completeness is a claim about
+// everything one plugin contributes to a file, so the claims of its preamble
+// and program hooks are the same plugin's claim and must not be attributed
+// separately.
+func (state linkedPluginState) contextAt(index int, entry PluginEntry) PluginContext {
   inputs := state.inputs.newScope()
+  declaration := state.declarations.forPlugin(index)
   return PluginContext{
     Cwd:                            state.cwd,
     Entry:                          entry,
@@ -588,6 +695,10 @@ func (state linkedPluginState) context(entry PluginEntry) PluginContext {
     reportHostInputHashUnknown:     inputs.invalidateHash,
     reportHostInputRealpath:        inputs.addRealpath,
     reportHostInputRealpathUnknown: inputs.invalidateRealpath,
+    reportFileDependency:           declaration.addDependency,
+    reportFileDependencyRejected:   declaration.rejectDependency,
+    reportFileComplete:             declaration.addComplete,
+    reportEveryFileComplete:        declaration.completeEveryFile,
   }
 }
 

package/driver/transform_dependencies.go

@@ -0,0 +1,283 @@
+package driver
+
+import (
+  "sort"
+  "sync"
+)
+
+// TransformDependencies is the transform envelope's dependency side channel:
+// the per-file input lists a producer reports and the subset of files whose
+// list is complete.
+//
+// A producer that declares nothing leaves both fields empty, so its envelope is
+// byte-identical to what it was before this existed. The lane with no linked
+// plugin at all is the deliberate exception: nothing there can contribute to a
+// file, so every file is listed.
+type TransformDependencies struct {
+  // Complete lists the files whose Dependencies entry is the whole input set
+  // beyond the file itself and the universal compiler-option chain.
+  Complete []string
+  // Dependencies maps a transformed file to the files whose content influenced
+  // its output, keyed and valued like every other envelope section.
+  Dependencies map[string][]string
+}
+
+// TransformDependenciesFor computes the dependency side channel for the files
+// this program transforms, keyed against cwd.
+//
+// **The rule that makes any of this declarable.** ttsc's own source-to-source
+// transform is syntactic: the built-in native host answers with each file's
+// parsed text, and the linked-plugin generic host prints the parsed AST through
+// a printer that is handed neither a checker nor an emit resolver. Neither lane
+// runs the emit transformer chain, so none of the type-driven lowerings happen
+// there — no type-driven import elision, no `design:type` metadata, no `enum`,
+// `namespace`, or JSX lowering, and no declaration emit. The output of a file
+// the host alone produced is therefore a function of that file's own text and
+// the compiler options, and nothing the type system knows about any other file
+// can change it.
+//
+// What that leaves is the plugins. A source preamble is prepended to every
+// file's text before parsing, and a program plugin mutates the parsed AST, so
+// either can make an output depend on anything it consulted — including, for a
+// checker-driven plugin, the whole type graph. Such a plugin is the only party
+// that knows what it read, which is why the declaration is per (plugin, file)
+// and why a file is complete only when every plugin that can contribute to it
+// declared it. An emit-only plugin is not a contributor here: its transform runs
+// in `build`, which produces no envelope.
+//
+// With no linked plugin at all the contributor set is empty and every file is
+// complete with an empty list, which is the rule above stated for the lane that
+// has nothing but the host in it. A contributor that declares nothing leaves
+// every file unlisted, which is exactly the behaviour of every producer written
+// before this existed.
+//
+// An embedder that supplies LoadProgramOptions.SourcePreamble itself, rather
+// than obtaining it from a linked plugin, makes the same claim about that text
+// by calling this: the preamble must be a function of inputs its envelope
+// reports elsewhere, the way a plugin's preamble is a function of the config
+// files it reports as host inputs.
+func (p *Program) TransformDependenciesFor(cwd string) TransformDependencies {
+  if p == nil {
+    return TransformDependencies{}
+  }
+  // Declarations are made from inside the plugin hooks, so they exist only
+  // after those hooks ran. The apply is latched, so this cannot re-run them.
+  _ = p.ApplyLinkedPlugins()
+  files := p.sourceFilesRaw()
+  keys := make([]string, 0, len(files))
+  for _, file := range files {
+    keys = append(keys, TransformOutputKey(cwd, file.FileName()))
+  }
+  return p.plugins.transformDependencies(keys)
+}
+
+// transformDependencies aggregates every contributing plugin's declarations
+// over the envelope keys of the transformed files.
+func (state linkedPluginState) transformDependencies(keys []string) TransformDependencies {
+  return aggregateTransformDependencies(keys, state.transformContributors(), state.declarations)
+}
+
+// aggregateTransformDependencies folds the declarations of the given
+// contributors into one envelope side channel.
+//
+// Separated from the entry classification above so the aggregation rule can be
+// exercised without the process-wide plugin registry that classification reads.
+func aggregateTransformDependencies(keys []string, contributors []int, declarations *pluginFileDeclarations) TransformDependencies {
+  out := TransformDependencies{}
+  for _, key := range keys {
+    declared := 0
+    inputs := map[string]struct{}{}
+    for _, index := range contributors {
+      declaration := declarations.lookup(index)
+      if declaration == nil {
+        continue
+      }
+      for _, input := range declaration.dependenciesOf(key) {
+        // A file never depends on itself: the file's own text is outside the
+        // completeness contract by construction, and a self-edge would only
+        // make consumers register the module they are already transforming.
+        if input != key {
+          inputs[input] = struct{}{}
+        }
+      }
+      if declaration.declaresComplete(key) {
+        declared++
+      }
+    }
+    if len(inputs) != 0 {
+      out.Dependencies = appendDependencyEntry(out.Dependencies, key, inputs)
+    }
+    if declared == len(contributors) {
+      out.Complete = append(out.Complete, key)
+    }
+  }
+  sort.Strings(out.Complete)
+  return out
+}
+
+// appendDependencyEntry records one file's sorted dependency list, allocating
+// the map only for a producer that reported something.
+func appendDependencyEntry(into map[string][]string, key string, inputs map[string]struct{}) map[string][]string {
+  if into == nil {
+    into = map[string][]string{}
+  }
+  entry := make([]string, 0, len(inputs))
+  for input := range inputs {
+    entry = append(entry, input)
+  }
+  sort.Strings(entry)
+  into[key] = entry
+  return into
+}
+
+// transformContributors returns the indexes of the linked plugin entries that
+// can influence source-to-source transform output.
+//
+// An entry with no registered plugin cannot be inspected, so it counts as a
+// contributor that declared nothing; the host fails that entry elsewhere, and
+// until it does, silence is the conservative answer.
+func (state linkedPluginState) transformContributors() []int {
+  contributors := make([]int, 0, len(state.entries))
+  for index := range state.entries {
+    plugin, ok := registeredPlugin(index)
+    if !ok {
+      contributors = append(contributors, index)
+      continue
+    }
+    _, preamble := plugin.(SourcePreamblePlugin)
+    _, program := plugin.(ProgramPlugin)
+    if preamble || program {
+      contributors = append(contributors, index)
+    }
+  }
+  return contributors
+}
+
+// pluginFileDeclarations holds one declaration record per linked plugin entry.
+type pluginFileDeclarations struct {
+  mu      sync.Mutex
+  plugins map[int]*pluginFileDeclaration
+}
+
+// pluginFileDeclaration is one plugin's reported dependencies and completeness
+// claims, keyed by envelope key.
+type pluginFileDeclaration struct {
+  complete     map[string]struct{}
+  completeAll  bool
+  dependencies map[string]map[string]struct{}
+  mu           sync.Mutex
+  // rejected holds the files whose reported list this plugin could not state
+  // in full, because one of its members was unusable as a key.
+  rejected map[string]struct{}
+}
+
+func newPluginFileDeclarations() *pluginFileDeclarations {
+  return &pluginFileDeclarations{plugins: map[int]*pluginFileDeclaration{}}
+}
+
+// forPlugin returns the declaration record of one plugin entry, creating it on
+// first use. A nil ledger still answers a usable record so a hand-built state
+// (unit tests, embedders) never panics through a plugin's reporting call.
+func (declarations *pluginFileDeclarations) forPlugin(index int) *pluginFileDeclaration {
+  record := &pluginFileDeclaration{
+    complete:     map[string]struct{}{},
+    dependencies: map[string]map[string]struct{}{},
+    rejected:     map[string]struct{}{},
+  }
+  if declarations == nil {
+    return record
+  }
+  declarations.mu.Lock()
+  defer declarations.mu.Unlock()
+  if existing, ok := declarations.plugins[index]; ok {
+    return existing
+  }
+  declarations.plugins[index] = record
+  return record
+}
+
+// lookup returns the declaration record of one plugin entry, or nil when that
+// entry never reported anything.
+func (declarations *pluginFileDeclarations) lookup(index int) *pluginFileDeclaration {
+  if declarations == nil {
+    return nil
+  }
+  declarations.mu.Lock()
+  defer declarations.mu.Unlock()
+  return declarations.plugins[index]
+}
+
+func (declaration *pluginFileDeclaration) addDependency(file string, dependency string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  entry, ok := declaration.dependencies[file]
+  if !ok {
+    entry = map[string]struct{}{}
+    declaration.dependencies[file] = entry
+  }
+  entry[dependency] = struct{}{}
+}
+
+// rejectDependency withdraws this plugin's completeness claim for one file.
+func (declaration *pluginFileDeclaration) rejectDependency(file string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.rejected[file] = struct{}{}
+}
+
+func (declaration *pluginFileDeclaration) addComplete(file string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.complete[file] = struct{}{}
+}
+
+func (declaration *pluginFileDeclaration) completeEveryFile() {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.completeAll = true
+}
+
+func (declaration *pluginFileDeclaration) dependenciesOf(file string) []string {
+  if declaration == nil {
+    return nil
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  entry, ok := declaration.dependencies[file]
+  if !ok {
+    return nil
+  }
+  out := make([]string, 0, len(entry))
+  for input := range entry {
+    out = append(out, input)
+  }
+  return out
+}
+
+func (declaration *pluginFileDeclaration) declaresComplete(file string) bool {
+  if declaration == nil {
+    return false
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  if _, rejected := declaration.rejected[file]; rejected {
+    return false
+  }
+  if declaration.completeAll {
+    return true
+  }
+  _, ok := declaration.complete[file]
+  return ok
+}

package/driver/transform_dependencies_declares_every_file_without_a_contributor_test.go

@@ -0,0 +1,28 @@
+package driver
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestTransformDependenciesDeclaresEveryFileWithoutAContributor verifies the
+// rule the host declares under when nothing else can contribute: a
+// source-to-source transform is syntactic, so a file the host alone produced
+// depends on its own text and the compiler options, and on nothing else.
+//
+// With an empty contributor set the aggregation is vacuously satisfied for
+// every file, which is what lets a plugin-free project's consumer stop
+// revalidating each delivered module's whole reference closure
+// (samchon/ttsc#1259).
+func TestTransformDependenciesDeclaresEveryFileWithoutAContributor(t *testing.T) {
+  keys := []string{"src/main.ts", "src/types.ts"}
+
+  out := aggregateTransformDependencies(keys, nil, newPluginFileDeclarations())
+
+  if !reflect.DeepEqual(out.Complete, []string{"src/main.ts", "src/types.ts"}) {
+    t.Fatalf("expected every file declared complete, got %v", out.Complete)
+  }
+  if out.Dependencies != nil {
+    t.Fatalf("expected no dependency entries, got %v", out.Dependencies)
+  }
+}

package/driver/transform_dependencies_drops_a_self_reported_dependency_test.go

@@ -0,0 +1,21 @@
+package driver
+
+import "testing"
+
+// TestTransformDependenciesDropsASelfReportedDependency verifies a file never
+// enters its own dependency list.
+//
+// The file's own text sits outside the completeness contract by construction —
+// every consumer compares it before anything else — so a self-edge would only
+// make a bundler register the module it is already transforming as one of that
+// module's watch inputs.
+func TestTransformDependenciesDropsASelfReportedDependency(t *testing.T) {
+  declarations := newPluginFileDeclarations()
+  declarations.forPlugin(0).addDependency("src/main.ts", "src/main.ts")
+
+  out := aggregateTransformDependencies([]string{"src/main.ts"}, []int{0}, declarations)
+
+  if len(out.Dependencies) != 0 {
+    t.Fatalf("expected the self-reported dependency to be dropped, got %v", out.Dependencies)
+  }
+}

package/driver/transform_dependencies_keys_a_reported_path_like_the_envelope_test.go

@@ -0,0 +1,46 @@
+package driver
+
+import (
+  "path/filepath"
+  "reflect"
+  "testing"
+)
+
+// TestTransformDependenciesKeysAReportedPathLikeTheEnvelope verifies a plugin's
+// reported paths reach the envelope under the same key convention as every other
+// section.
+//
+// A plugin reports the spellings its host handed it — absolute program file
+// names, which the compiler normalizes to forward slashes on every platform, or
+// paths relative to the plugin's cwd. Keying either differently from
+// `typescript` would leave a consumer unable to join the sections at all, and on
+// Windows the two spellings differ by separator alone, which is exactly the kind
+// of mismatch that passes on POSIX CI and fails on a developer's machine.
+func TestTransformDependenciesKeysAReportedPathLikeTheEnvelope(t *testing.T) {
+  // A real directory, so the absolute spellings below are absolute under the
+  // running platform's own rule rather than under POSIX's alone.
+  cwd := t.TempDir()
+  declarations := newPluginFileDeclarations()
+  ctx := PluginContext{
+    Cwd:                  cwd,
+    reportFileDependency: declarations.forPlugin(0).addDependency,
+    reportFileComplete:   declarations.forPlugin(0).addComplete,
+  }
+
+  // The compiler's own spelling of a source file, and a cwd-relative one.
+  ctx.ReportFileDependency(
+    filepath.ToSlash(filepath.Join(cwd, "src", "main.ts")),
+    filepath.Join("src", "consulted.d.ts"),
+  )
+  ctx.ReportFileDependenciesComplete(filepath.Join(cwd, "src", "main.ts"))
+  ctx.ReportFileDependency("   ", "src/ignored.d.ts")
+
+  out := aggregateTransformDependencies([]string{"src/main.ts"}, []int{0}, declarations)
+
+  if !reflect.DeepEqual(out.Complete, []string{"src/main.ts"}) {
+    t.Fatalf("expected the reported file to key like the envelope, got %v", out.Complete)
+  }
+  if !reflect.DeepEqual(out.Dependencies["src/main.ts"], []string{"src/consulted.d.ts"}) {
+    t.Fatalf("expected the reported dependency to key like the envelope, got %v", out.Dependencies)
+  }
+}