ttsc 0.34.0 → 0.34.2

package/src/internal/CompilerResultAdapter.ts

@@ -217,15 +217,17 @@ function toCompilerResult(project: ProjectResult): ITtscCompilerResult {
 }
 
 /**
- * Adapt source/build outcome and copy optional advisory references only when
- * present.
+ * Adapt source/build outcome and preserve optional advisory values. Mapper
+ * project inputs join each source's declared dependencies on success and
+ * failure; they do not become compiler-read observations or completeness
+ * certificates.
  *
- * @evidence contracts/common.md#principled-implementation Undefined advisory fields are omitted; present empty/false values and references survive both success and failure, alongside the existing diagnostic decision.
+ * @evidence contracts/common.md#principled-implementation Undefined advisory fields are omitted and present empty/false values survive both success and failure. Universal mapper declarations join source dependencies with own-key safety; compiler completeness and read witnesses retain their independent meaning.
  * @evidence contracts/common.md#clear-and-simple-design One optional-field projection is shared by the two result branches.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The adapter does not manufacture graph, host-read or completeness proof and does not discard it solely because the build failed.
- * @evidence contracts/common.md#meaningful-documentation The native sentence states omission policy and reference ownership.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes mapper declarations from read proof and completeness on both result branches.
  * @evidenceExclude contracts/portability.md#os-neutral-implementation Advisory values are passed through without native path normalization or capability inference.
- * @evidence contracts/performance.md#efficient-algorithms Fixed optional-field checks retain references without scanning map text; diagnostic classification and empty-failure formatting have their delegated data costs.
+ * @evidence contracts/performance.md#efficient-algorithms Optional fields retain references unless mapper inputs require a per-source Set union. Work and copied storage follow source keys plus each source's dependency/input text; diagnostic classification and failure formatting keep their delegated costs.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work This adaptation coordinates no reusable compiler/worker or outcome cache.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned source/advisory objects remain reachable under caller ownership; this operation owns no process, lease or historical registry.
  */
@@ -233,7 +235,7 @@ export function toCompilerTransformation(
   project: ProjectTransformation,
 ): ITtscCompilerTransformation {
   const {
-    dependencies,
+    dependencies: reportedDependencies,
     dependenciesComplete,
     graph,
     hostInputHashes,
@@ -247,6 +249,27 @@ export function toCompilerTransformation(
     typescript,
     volatile,
   } = project;
+  let dependencies = reportedDependencies;
+  if (graph?.contentMapperInputs?.length) {
+    const keys = new Set([
+      ...Object.keys(typescript),
+      ...Object.keys(graph.edges),
+    ]);
+    dependencies = Object.fromEntries([
+      ...Object.entries(dependencies ?? {}).filter(([key]) => !keys.has(key)),
+      ...Array.from(keys, (key) => [
+        key,
+        [
+          ...new Set([
+            ...(Object.hasOwn(dependencies ?? {}, key)
+              ? dependencies![key]!
+              : []),
+            ...graph.contentMapperInputs!,
+          ]),
+        ].filter((input) => input !== key),
+      ]),
+    ]);
+  }
   const advisoryFields = {
     ...(dependencies === undefined ? {} : { dependencies }),
     ...(dependenciesComplete === undefined ? {} : { dependenciesComplete }),

package/src/structures/ITtscCompilerTransformation.ts

@@ -51,6 +51,23 @@ export namespace ITtscCompilerTransformation {
    * @evidence contracts/portability.md#os-neutral-implementation Graph keys use the producer's cwd-relative slash spelling with absolute slash paths for outside-root or cross-volume inputs; this protocol spelling is distinct from reported native realpaths carried by inputRealpaths and observations, which can retain lexical fallback on native VFS errors. The reported compiler case policy governs compiler membership comparisons rather than an OS-name assumption; absent policy or proof does not establish native filesystem capabilities.
    */
   export interface IReferenceGraph {
+    /**
+     * Effective native possible-root suffixes and output-directory exclusions.
+     * A report that differs from a host's provisional policy requires a new
+     * membership walk. Directory paths are absolute; null clears an option.
+     * Authored files/include and explicit excludes remain configuration
+     * inputs.
+     */
+    membership?: {
+      /** Original suffix spellings admitted by the compiler and its mappers. */
+      inputExtensions: string[];
+
+      /** Effective absolute output directory, or null when unset. */
+      outDir: string | null;
+
+      /** Effective absolute declaration directory, or null when unset. */
+      declarationDir: string | null;
+    };
     /**
      * Direct resolved references per file: imports, re-exports, `///
      * <reference>` targets, and type reference directives — type-only edges
@@ -82,10 +99,20 @@ export namespace ITtscCompilerTransformation {
 
     /**
      * Automatic type discovery and resolution inputs that affect every source,
-     * including effective type-root directory membership.
+     * including compiler response files and effective type-root directory
+     * membership. Failed loads can retain their observed CLI/config recovery
+     * paths here without a completed Program or source population.
      */
     resolutionInputs?: string[];
 
+    /**
+     * Mapper package manifests and dynamic project watchedFiles. These are
+     * declared dependencies for every output, including files whose plugin
+     * dependencies are complete. They carry no compiler-read proof: consumers
+     * must witness them before compilation and compare afterward.
+     */
+    contentMapperInputs?: string[];
+
     /**
      * Filesystem predicates recorded during construction and resolver replay
      * for this graph. Each property is independent: `fileExists: false` and

package/targets/7.1/bridge/compiler/neutral.go

@@ -3,6 +3,8 @@ package compiler
 import (
   "context"
   "errors"
+  "path/filepath"
+  "sort"
   "sync"
 
   innerast "github.com/microsoft/TypeScript/tsc/internal/ast"
@@ -52,7 +54,7 @@ func NewHost(currentDirectory innertspath.RootedDirectoryPath, fs innervfs.FS, d
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The compiler's own runExternalCode gate and mapper resolution decide whether mappers run; no ttsc authorization or mapping policy is added.
 // @evidence contracts/common.md#meaningful-documentation Native prose states when mappers run, the nil meaning and the 7.0 difference.
 // @evidence contracts/portability.md#os-neutral-implementation Mapper processes start through spawnContentMapper's os/exec boundary in each mapper package's directory; the supplied FS owns every file read.
-// @evidenceExclude contracts/performance.md#efficient-algorithms The type stores two handles and chooses no algorithm.
+// @evidenceExclude contracts/performance.md#efficient-algorithms This declaration chooses no algorithm; its fields retain shared mapper state and resolved manifest names.
 // @evidence contracts/performance.md#reuse-equivalent-work Every host built from one ProjectHosts shares one mapper project, so an incremental generation reuses the processes the first generation started.
 // @evidence contracts/performance.md#bound-retention-and-release-resources The mapper project and host, and with them every spawned mapper process, live until Close; Close releases them once.
 type ProjectHosts struct {
@@ -60,6 +62,7 @@ type ProjectHosts struct {
   project   contentmapper.Project
   closeOnce sync.Once
   closeErr  error
+  manifests []string
 }
 
 // NewProjectHosts returns the hosts of Programs built from config. It starts
@@ -69,8 +72,8 @@ type ProjectHosts struct {
 // @evidence contracts/common.md#clear-and-simple-design One gate returns either a nil value or a value holding the mapper project.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Mapper resolution and its diagnostics stay with the config parser; this function adds none.
 // @evidence contracts/common.md#meaningful-documentation Native prose states that construction starts no process.
-// @evidence contracts/portability.md#os-neutral-implementation Construction performs no native operation; mapper processes start later through spawnContentMapper.
-// @evidenceExclude contracts/performance.md#efficient-algorithms Construction checks one option and one slice length.
+// @evidence contracts/portability.md#os-neutral-implementation Native filepath.Join constructs manifest paths in resolved package directories; mapper processes start later through spawnContentMapper.
+// @evidence contracts/performance.md#efficient-algorithms Construction checks the gate and copies each configured mapper package directory into a manifest path. Cost and returned path storage follow mapper count and path text.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call opens its own mapper state; callers share it by holding the value.
 // @evidence contracts/performance.md#bound-retention-and-release-resources The returned value owns the mapper host and project until Close.
 func NewProjectHosts(config *innertsoptions.ParsedCommandLine) *ProjectHosts {
@@ -79,8 +82,15 @@ func NewProjectHosts(config *innertsoptions.ParsedCommandLine) *ProjectHosts {
   }
   diagnosticLocale, _ := innerlocale.Parse(config.CompilerOptions().Locale)
   mappers := contentmapper.NewHost(context.Background(), contentmapper.SpawnerFunc(spawnContentMapper), diagnosticLocale)
+  manifests := make([]string, 0, len(config.ContentMappers()))
+  for _, mapper := range config.ContentMappers() {
+    if mapper.PackageDirectory != "" {
+      manifests = append(manifests, filepath.Join(string(mapper.PackageDirectory), "package.json"))
+    }
+  }
   return &ProjectHosts{
-    mappers: mappers,
+    manifests: manifests,
+    mappers:   mappers,
     project: mappers.Project(contentmapper.ProjectSpec{
       ConfigFileName:  config.ConfigName(),
       Mappers:         config.ContentMappers(),
@@ -89,6 +99,31 @@ func NewProjectHosts(config *innertsoptions.ParsedCommandLine) *ProjectHosts {
   }
 }
 
+// Dependencies returns mapper manifests and upstream-declared dynamic inputs.
+// WatchedFiles can open dynamic project configuration; its error is returned
+// alongside manifests so callers keep recovery inputs without claiming success.
+//
+// @evidence contracts/common.md#principled-implementation Uses the pinned upstream Project.WatchedFiles declaration and resolved mapper package directories; it does not infer reads from mapper code.
+// @evidence contracts/common.md#clear-and-simple-design One projection transfers the project-owned dependency population without changing the mapper protocol.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Upstream errors remain errors and manifests remain available for recovery; no post-compile hash is invented.
+// @evidence contracts/common.md#meaningful-documentation Native prose documents lazy opening, declaration scope and partial error results.
+// @evidence contracts/portability.md#os-neutral-implementation Native filepath.Join anchors manifests in resolved package directories; upstream watched paths retain their absolute native spelling.
+// @evidence contracts/performance.md#efficient-algorithms Copies declared input names and sorts them; upstream WatchedFiles can open dynamic mapper projects and perform protocol IO.
+// @evidence contracts/performance.md#reuse-equivalent-work Upstream project state shares opened configuration; each returned slice is independently owned.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned names escape to the caller; ProjectHosts still owns mapper lifetime through Close.
+func (h *ProjectHosts) Dependencies() ([]string, error) {
+  if h == nil {
+    return nil, nil
+  }
+  inputs := append([]string(nil), h.manifests...)
+  watched, err := h.project.WatchedFiles()
+  for _, file := range watched {
+    inputs = append(inputs, string(file))
+  }
+  sort.Strings(inputs)
+  return inputs, err
+}
+
 // Host returns a compiler host over fs, like NewHost, that transforms
 // content-mapped files through this project's mappers.
 //

package/targets/7.1/bridge/compiler/resolution.go

@@ -3,6 +3,7 @@
 package compiler
 
 import (
+  "slices"
   "time"
 
   "github.com/microsoft/TypeScript/tsc/internal/ast"
@@ -84,8 +85,11 @@ type ProgramResolutionTask struct {
   redirectedReference module.ResolvedProjectReference
 }
 
-// ProgramResolutionTasks returns every cached module and type-reference
-// resolution, including unresolved entries and automatic type directives.
+// ProgramResolutionTasks returns cached filesystem module and type-reference
+// resolutions, including unresolved entries and automatic type directives.
+// Source-local ambient module sentinels are excluded because the compiler
+// resolves them from source content without a filesystem query. Imports of
+// the same name from other sources and external-module augmentations remain.
 // A nil Program returns nil. Returned tasks retain Program option and redirect
 // pointers; the caller owns their storage and must preserve that context.
 // Enumeration order follows compiler maps and is not sorted. TargetFile is
@@ -93,12 +97,12 @@ type ProgramResolutionTask struct {
 // initialize referenced configs' input/output maps and query a native realpath
 // for a preserved symlink redirect; it does not replay module resolution.
 //
-// @evidence contracts/common.md#principled-implementation Enumerating the resident compiler's module and type-directive caches retains both successes and failures; containing paths recover loaded-source or semantic-config spelling, and expected results include package, target and link identity.
+// @evidence contracts/common.md#principled-implementation Enumerating the resident compiler's module and type-directive caches retains filesystem successes and failures while excluding names in the containing source's AmbientModuleNames, matching fileLoader's local-ambient branch. Their declarations remain source-content inputs; other sources and external-module augmentations retain their filesystem tasks. Containing paths recover loaded-source or semantic-config spelling, and expected results include package, target and link identity.
 // @evidence contracts/common.md#clear-and-simple-design One append closure shares task construction across both compiler cache traversals, while private helpers own source-redirect and project-reference context reconstruction.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts The inferred-types filename is the compiler's automatic-directive context, and recovering its lexical directory addresses actual case-canonical cache keys without relaxing result comparison.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Source-local AmbientModuleNames membership mirrors the compiler's skipped lookup, not a consumer name or an empty-result filter; genuine unresolved tasks remain. The inferred-types filename is the compiler's automatic-directive context, and recovering its lexical directory addresses actual case-canonical cache keys without relaxing result comparison.
 // @evidence contracts/common.md#meaningful-documentation Native prose states cache coverage, nil behavior and retained Program-pointer lifetime; task fields document the lexical-versus-loaded path distinctions.
 // @evidence contracts/portability.md#os-neutral-implementation Compiler canonical cache keys are not replayed as lexical filenames: source/config context restores spelling, and redirects use actual filesystem Realpath plus Program case policy rather than OS guesses.
-// @evidence contracts/performance.md#efficient-algorithms Two cache traversals append one task per resolution and share one reference-context snapshot. Additional work includes reference-graph traversal, source/output map scans and first-use output-path construction, path hashing/canonicalization and selected native Realpath queries for symlink context. Map/string backing and referenced config/source population matter beyond just the returned task count; extraction does not independently replay imports.
+// @evidence contracts/performance.md#efficient-algorithms Two cache traversals append one task per filesystem resolution and share one reference-context snapshot. Each module entry looks up its containing source and scans that source's ambient names, matching upstream's membership procedure without another retained index. Additional work includes reference-graph traversal, source/output map scans and first-use output-path construction, path hashing/canonicalization and selected native Realpath queries for symlink context. Map/string backing and referenced config/source population matter beyond just the returned task count; extraction does not independently replay imports.
 // @evidence contracts/performance.md#reuse-equivalent-work Cached resident resolutions and one shared project-reference context are reused across tasks from the same Program, preserving their option and redirect identity rather than sharing across changed programs.
 // @evidence contracts/performance.md#bound-retention-and-release-resources The returned task slice retains option, expected-result strings and redirect metadata, plus a shared context's directory set and output-to-reference map when present. These pointers can keep parsed project/config/source graphs reachable beyond the shallow map size. First-use input/output maps remain owned by referenced configs; invocation-local traversal/snapshot containers add no independent historical registry or running task, and callers bound how long they retain the result.
 func ProgramResolutionTasks(program *Program) []ProgramResolutionTask {
@@ -154,6 +158,11 @@ func ProgramResolutionTasks(program *Program) []ProgramResolutionTask {
     })
   }
   program.ForEachResolvedModule(func(resolution *module.ResolvedModule, name string, mode core.ResolutionMode, filePath tspath.PathKey) {
+    // fileLoader records local ambient names as empty cache sentinels without
+    // asking the filesystem resolver. Their source content owns the proof.
+    if source := program.GetSourceFileByPath(filePath); source != nil && slices.Contains(source.AmbientModuleNames, name) {
+      return
+    }
     appendTask(ProgramResolutionKindModule, name, mode, filePath, moduleResolutionResult(resolution), resolution)
   }, nil)
   program.ForEachResolvedTypeReferenceDirective(func(resolution *module.ResolvedTypeReferenceDirective, name string, mode core.ResolutionMode, filePath tspath.PathKey) {

package/utility/host.go

@@ -48,6 +48,9 @@ type hostOptions struct {
   // host sets it (to an OverlayFS), so build/check/transform leave it nil and
   // LoadProgram falls back to the default filesystem.
   fs vfs.FS
+
+  // failureInputs receives the loader's actual pre-Program recovery graph.
+  failureInputs func(*driver.TransformGraph)
 }
 
 // transformResult is the JSON envelope written to stdout by RunTransform.
@@ -115,8 +118,8 @@ func RunCheck(args []string) int {
 //
 // After successful flag admission, requested metadata is attempted on both
 // successful and failed checks and belongs to that check generation. A missing
-// generation is explicitly incomplete; rejected flag admission installs no
-// publication defer. Input authority does not erase status or diagnostics.
+// generation is explicitly incomplete but retains observed load-recovery paths.
+// Rejected flag admission installs no publication defer. Input authority does not erase status or diagnostics.
 // Callers own the metadata artifact's removal and supplied-stream lifetime.
 // Diagnostic/report writes are best-effort and are not delivery receipts.
 //
@@ -135,9 +138,13 @@ func RunCheckWithIO(args []string, stdout, stderr io.Writer) (status int) {
   }
   opts.noEmit = true
   var prog *driver.Program
+  var recovery *driver.TransformGraph
+  if opts.checkObservationsJSON != "" {
+    opts.failureInputs = func(graph *driver.TransformGraph) { recovery = graph }
+  }
   defer func() {
     if opts.checkObservationsJSON != "" {
-      if err := driver.WriteCheckObservationsJSON(opts.checkObservationsJSON, prog); err != nil {
+      if err := driver.WriteCheckRecoveryObservationsJSON(opts.checkObservationsJSON, prog, recovery); err != nil {
         fmt.Fprintf(opts.stderr, "ttsc utility: check observations write failed: %v\n", err)
         if status == 0 {
           status = 3
@@ -307,8 +314,9 @@ func RunTransform(args []string) int {
 // Failed projects retain diagnostics and recovery inputs but publish no partial
 // TypeScript. Encoding or response-write failure returns 3; project failure
 // returns 2.
-// Recovery envelopes require a loaded generation; flag admission or load failure
-// returns before response construction. A loaded generation's graph is captured
+// Rejected flag admission or a loader error returns before response construction.
+// Config/argument diagnostics can retain observed recovery predicates without a
+// Program. A loaded generation's graph is captured
 // before linked program hooks mutate its ASTs. Diagnostic stream reporting is
 // best-effort; response encoding and returned write errors determine delivery
 // status. Callers own the supplied stream lifetimes.
@@ -326,16 +334,20 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
   if !ok {
     return 2
   }
+  out := transformResult{TypeScript: map[string]string{}}
+  opts.failureInputs = func(graph *driver.TransformGraph) { out.Graph = graph }
   prog, _, diags, ok := loadUtilityProgramWithDiagnostics(opts)
   if !ok {
     return 2
   }
-  out := transformResult{TypeScript: map[string]string{}}
   if prog != nil {
     defer prog.Close()
     // The same failed Program owns the missing resolution candidates needed
     // for recovery. Capture them before closing it or applying mutations.
     out.Graph = driver.NewTransformGraph(prog, opts.cwd)
+  } else {
+    unavailable := false
+    out.ObservationsComplete = &unavailable
   }
   if len(diags) != 0 {
     driver.WritePrettyDiagnostics(opts.stderr, diags, opts.cwd)
@@ -605,6 +617,7 @@ func loadUtilityProgramWithDiagnostics(opts hostOptions) (*driver.Program, []dri
     Checkers:           opts.checkers,
     TsgoArgs:           opts.tsgoArgs,
     FS:                 opts.fs,
+    OnFailureInputs:    opts.failureInputs,
   })
   if err != nil {
     fmt.Fprintf(opts.stderr, "ttsc utility: %v\n", err)