ttsc 0.28.4 → 0.28.6

package/src/compiler/internal/transformProjectInMemory.ts

@@ -21,6 +21,7 @@ import { resolveTsgo } from "./resolveTsgo";
 import { appendBuildOutput, normalizeBuildOutput } from "./runBuild";
 import {
   assertSharedHostCompatibility,
+  clearInheritedSemanticConfigPath,
   clearInheritedTsgoArgs,
   inheritedSidecarEnv,
   linkedTransformPlugins,
@@ -622,6 +623,7 @@ function nativePluginEnv(
   // This lane forwards no tsgo argv of its own, so anything inherited belongs
   // to an outer ttsc run and must not reach these sidecars.
   clearInheritedTsgoArgs(env, options.env);
+  clearInheritedSemanticConfigPath(env, options.env);
   if (plugin?.stage === "transform") {
     const linked = linkedTransformPlugins(nativePlugins ?? []);
     if (linked.length !== 0) {
@@ -809,11 +811,9 @@ function parseGraphEdges(value: unknown): Record<string, string[]> | undefined {
  * compiler input proof. A section carrying nothing usable collapses to
  * `undefined`.
  *
- * `candidates` is the one optional member, so an empty one is left off the
- * result instead of being materialized as `{}`. The host omits the key when it
- * has no superseding candidate to report, and a consumer that narrows on the
- * declared optional type must see the same shape whether it reads the decoded
- * envelope or the wire.
+ * Optional resolver-input members are left off when empty. A consumer that
+ * narrows on their declared optional types therefore sees the same shape from
+ * the decoded envelope and the wire.
  */
 function parseReferenceGraph(
   value: unknown,
@@ -827,23 +827,34 @@ function parseReferenceGraph(
     edges?: unknown;
     globals?: unknown;
     inputHashes?: unknown;
+    inputObservations?: unknown;
     inputProofFailures?: unknown;
     inputRealpaths?: unknown;
+    resolutionInputs?: unknown;
   };
   const candidates = parseDependencyLists(section.candidates) ?? {};
   const edges = parseGraphEdges(section.edges) ?? {};
   const globals = parseFileList(section.globals) ?? [];
   const configs = parseFileList(section.configs) ?? [];
+  const resolutionInputs = parseFileList(section.resolutionInputs) ?? [];
   const inputHashes = parseGraphInputHashes(section.inputHashes);
-  const inputProofFailures = parseGraphInputProofFailures(
+  const parsedInputObservations = parseGraphInputObservations(
+    section.inputObservations,
+  );
+  const reportedInputProofFailures = parseGraphInputProofFailures(
     section.inputProofFailures,
   );
+  const inputProofFailures = {
+    ...reportedInputProofFailures,
+    ...parsedInputObservations.failures,
+  };
   const inputRealpaths = parseGraphInputRealpaths(section.inputRealpaths);
   if (
     Object.keys(candidates).length === 0 &&
     Object.keys(edges).length === 0 &&
     globals.length === 0 &&
-    configs.length === 0
+    configs.length === 0 &&
+    resolutionInputs.length === 0
   ) {
     return undefined;
   }
@@ -852,12 +863,186 @@ function parseReferenceGraph(
     configs,
     edges,
     globals,
+    ...(resolutionInputs.length === 0 ? {} : { resolutionInputs }),
     ...(inputHashes === undefined ? {} : { inputHashes }),
-    ...(inputProofFailures === undefined ? {} : { inputProofFailures }),
+    ...(parsedInputObservations.observations === undefined
+      ? {}
+      : { inputObservations: parsedInputObservations.observations }),
+    ...(Object.keys(inputProofFailures).length === 0
+      ? {}
+      : { inputProofFailures }),
     ...(inputRealpaths === undefined ? {} : { inputRealpaths }),
   };
 }
 
+/**
+ * Parse graph-keyed predicate observations and retain malformed entries as
+ * failures.
+ */
+function parseGraphInputObservations(value: unknown): {
+  failures?: Record<string, string>;
+  observations?: Record<string, ITtscCompilerTransformation.IInputObservation>;
+} {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  const failures: Record<string, string> = {};
+  const observations: Record<
+    string,
+    ITtscCompilerTransformation.IInputObservation
+  > = {};
+  for (const [file, entry] of Object.entries(value)) {
+    if (file.length === 0) continue;
+    const parsed = parseGraphInputObservation(entry);
+    if (parsed === "malformed" || parsed === "conflicting") {
+      failures[file] = `${parsed}-observation`;
+    } else {
+      observations[file] = parsed;
+    }
+  }
+  return {
+    ...(Object.keys(failures).length === 0 ? {} : { failures }),
+    ...(Object.keys(observations).length === 0 ? {} : { observations }),
+  };
+}
+
+/** Parse one predicate observation without guessing around a malformed member. */
+function parseGraphInputObservation(
+  value: unknown,
+): ITtscCompilerTransformation.IInputObservation | "conflicting" | "malformed" {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return "malformed";
+  }
+  const entry = value as Record<string, unknown>;
+  const observation: ITtscCompilerTransformation.IInputObservation = {};
+  if (Object.prototype.hasOwnProperty.call(entry, "accessibleEntries")) {
+    const accessible = entry.accessibleEntries;
+    if (
+      typeof accessible !== "object" ||
+      accessible === null ||
+      Array.isArray(accessible)
+    ) {
+      return "malformed";
+    }
+    const lists = accessible as Record<string, unknown>;
+    if (
+      !Array.isArray(lists.directories) ||
+      !lists.directories.every(
+        (name): name is string => typeof name === "string",
+      ) ||
+      !Array.isArray(lists.files) ||
+      !lists.files.every((name): name is string => typeof name === "string")
+    ) {
+      return "malformed";
+    }
+    observation.accessibleEntries = {
+      directories: [...lists.directories],
+      files: [...lists.files],
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "fileExists")) {
+    if (typeof entry.fileExists !== "boolean") return "malformed";
+    observation.fileExists = entry.fileExists;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "directoryExists")) {
+    if (typeof entry.directoryExists !== "boolean") return "malformed";
+    observation.directoryExists = entry.directoryExists;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "stat")) {
+    if (!["directory", "file", "missing"].includes(entry.stat as string)) {
+      return "malformed";
+    }
+    observation.stat = entry.stat as "directory" | "file" | "missing";
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "readFile")) {
+    const read = entry.readFile;
+    if (typeof read !== "object" || read === null || Array.isArray(read)) {
+      return "malformed";
+    }
+    const result = read as Record<string, unknown>;
+    if (result.ok === false && result.hash === undefined) {
+      observation.readFile = { ok: false };
+    } else if (
+      result.ok === true &&
+      typeof result.hash === "string" &&
+      /^[0-9a-f]{64}$/.test(result.hash)
+    ) {
+      observation.readFile = { hash: result.hash, ok: true };
+    } else {
+      return "malformed";
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "realpath")) {
+    const realpath = entry.realpath;
+    if (
+      typeof realpath !== "object" ||
+      realpath === null ||
+      Array.isArray(realpath)
+    ) {
+      return "malformed";
+    }
+    const result = realpath as Record<string, unknown>;
+    if (result.ok === false && result.path === undefined) {
+      observation.realpath = { ok: false };
+    } else if (
+      result.ok === true &&
+      typeof result.path === "string" &&
+      path.isAbsolute(result.path)
+    ) {
+      observation.realpath = { ok: true, path: path.resolve(result.path) };
+    } else {
+      return "malformed";
+    }
+  }
+  if (Object.keys(observation).length === 0) return "malformed";
+  return graphInputObservationCompatible(observation)
+    ? observation
+    : "conflicting";
+}
+
+/** Whether one predicate set can describe a single stable filesystem state. */
+function graphInputObservationCompatible(
+  observation: ITtscCompilerTransformation.IInputObservation,
+): boolean {
+  const { accessibleEntries, directoryExists, fileExists, readFile, stat } =
+    observation;
+  const hasAccessibleEntries =
+    accessibleEntries !== undefined &&
+    (accessibleEntries.directories.length !== 0 ||
+      accessibleEntries.files.length !== 0);
+  if (
+    hasAccessibleEntries &&
+    (fileExists === true ||
+      directoryExists === false ||
+      (stat !== undefined && stat !== "directory") ||
+      readFile?.ok === true)
+  ) {
+    return false;
+  }
+  if (fileExists === true && directoryExists === true) return false;
+  if (
+    stat === "directory" &&
+    (fileExists === true || directoryExists === false)
+  ) {
+    return false;
+  }
+  if (stat === "file" && (fileExists === false || directoryExists === true)) {
+    return false;
+  }
+  if (stat === "missing" && (fileExists === true || directoryExists === true)) {
+    return false;
+  }
+  if (
+    readFile?.ok === true &&
+    (fileExists === false ||
+      directoryExists === true ||
+      (stat !== undefined && stat !== "file"))
+  ) {
+    return false;
+  }
+  return true;
+}
+
 /** Parse graph-keyed machine-readable compiler proof-failure reasons. */
 function parseGraphInputProofFailures(
   value: unknown,

package/src/internal/projectInputPathIdentity.ts

@@ -52,7 +52,7 @@ export function createFilesystemPathIdentityContext(
   const realpaths = new Map<string, CachedRealpath>();
   const sensitivities = new Map<string, boolean>();
   const platform = operations.platform ?? process.platform;
-  const pathApi = platform === "win32" ? path.win32 : path;
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
   const throwOnRealpathError = operations.throwOnRealpathError ?? true;
   const realpath = operations.realpath ?? physicalRealpath;
   const lstat = operations.lstat ?? fs.lstatSync;
@@ -150,7 +150,7 @@ export function isFilesystemPathIdentityWithin(
   platform: NodeJS.Platform = process.platform,
 ): boolean {
   if (candidate === root) return true;
-  const separator = platform === "win32" ? path.win32.sep : path.sep;
+  const separator = platform === "win32" ? path.win32.sep : path.posix.sep;
   return candidate.startsWith(
     root.endsWith(separator) ? root : `${root}${separator}`,
   );
@@ -160,7 +160,7 @@ export function resolveFilesystemPath(
   location: string,
   platform: NodeJS.Platform = process.platform,
 ): string {
-  const pathApi = platform === "win32" ? path.win32 : path;
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
   if (platform !== "win32") {
     return pathApi.resolve(location);
   }
@@ -224,6 +224,7 @@ function filesystemDirectoryIsCaseSensitive(
     realpath(location: string): string;
   },
 ): boolean {
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
   let entries: string[];
   try {
     entries = operations.readdir(directory);
@@ -242,7 +243,7 @@ function filesystemDirectoryIsCaseSensitive(
     const alternate = alternateCase(name);
     if (alternate === name) continue;
     try {
-      operations.lstat(path.join(directory, alternate));
+      operations.lstat(pathApi.join(directory, alternate));
       return false;
     } catch (error) {
       if (isMissingFilesystemEntry(error)) {
@@ -261,13 +262,13 @@ function filesystemDirectoryIsCaseSensitive(
     // case-sensitive volume.
     let current = resolveFilesystemPath(directory, platform);
     while (true) {
-      const parent = path.dirname(current);
+      const parent = pathApi.dirname(current);
       if (parent === current) break;
-      const name = path.basename(current);
+      const name = pathApi.basename(current);
       const alternate = alternateCase(name);
       if (alternate !== name) {
         try {
-          operations.realpath(path.join(parent, alternate));
+          operations.realpath(pathApi.join(parent, alternate));
           return false;
         } catch (error) {
           if (isMissingFilesystemEntry(error) === false) throw error;

package/src/structures/ITtscCompilerTransformation.ts

@@ -50,27 +50,36 @@ export namespace ITtscCompilerTransformation {
     configs: string[];
 
     /**
-     * Resolution candidates that would outrank the selected target, keyed by
-     * importing file. The compiler already resolved the import to a graph edge;
-     * a listed path can be absent now or can be an existing unsuccessful probe,
-     * and its appearance or change can alter that edge without editing the
-     * importer or a recorded file.
-     *
-     * Hosts watch and hash these paths in addition to realized graph members. A
-     * candidate strictly below the selected target is deliberately absent: its
-     * creation cannot change resolution and must not invalidate a cache.
+     * Exact lexical filesystem inputs consulted by TypeScript-Go's module,
+     * type-reference, and triple-slash path resolution, keyed by source file.
+     * Hosts watch and prove these paths in addition to realized graph members.
      *
      * A host with nothing to report leaves the whole property out rather than
-     * sending an empty map, so `undefined` and "no superseding candidate" are
-     * the same observation on the wire and after decoding.
+     * sending an empty map, so `undefined` and "no resolver input" are the same
+     * observation on the wire and after decoding.
      */
     candidates?: Record<string, string[]>;
 
     /**
-     * SHA-256/null states returned by the compiler filesystem while this graph
-     * was being resolved, keyed in the same vocabulary as {@link edges}.
-     * Persistent hosts use them to reject a graph whose external file or
-     * superseding candidate changed during compilation.
+     * Automatic type discovery and resolution inputs that affect every source,
+     * including effective type-root directory membership.
+     */
+    resolutionInputs?: string[];
+
+    /**
+     * Exact filesystem predicates observed while the compiler constructed this
+     * graph. Each property is independent: `fileExists: false` and
+     * `directoryExists: true` describe one stable directory and do not
+     * conflict. Consumers re-run only the predicates present in an entry, so a
+     * failed file candidate is never reinterpreted as generic path absence.
+     */
+    inputObservations?: Record<string, IInputObservation>;
+
+    /**
+     * Legacy SHA-256/null projection of compiler filesystem observations, keyed
+     * in the same vocabulary as {@link edges}. Current consumers prefer
+     * {@link inputObservations} for candidate predicates and retain this pair
+     * for strict realized-file content validation.
      */
     inputHashes?: Record<string, string | null>;
 
@@ -78,14 +87,51 @@ export namespace ITtscCompilerTransformation {
     inputRealpaths?: Record<string, string | null>;
 
     /**
-     * Why the compiler could not produce a paired proof for a graph member.
-     * Values are stable machine-readable reason codes such as `content-changed`
-     * or `realpath-unavailable`; consumers use them only for diagnostics and
-     * still treat the missing proof as authoritative refusal.
+     * Why the compiler could not produce a trustworthy proof for a graph
+     * member. Values are stable machine-readable reason codes such as
+     * `content-changed` or `realpath-unavailable`; consumers use them only for
+     * diagnostics and still treat the missing proof as authoritative refusal.
      */
     inputProofFailures?: Record<string, string>;
   }
 
+  /** Predicate-preserving compiler filesystem proof for one lexical path. */
+  export interface IInputObservation {
+    /** Result returned by `GetAccessibleEntries`, preserving both name lists. */
+    accessibleEntries?: {
+      directories: string[];
+      files: string[];
+    };
+
+    /** Result returned by `DirectoryExists`, when the compiler called it. */
+    directoryExists?: boolean;
+
+    /** Result returned by `FileExists`, when the compiler called it. */
+    fileExists?: boolean;
+
+    /** Result returned by `ReadFile`, including decoded-text content identity. */
+    readFile?:
+      | { ok: false }
+      | {
+          hash: string;
+          ok: true;
+        };
+
+    /** Result returned by `Realpath` or captured beside a successful predicate. */
+    realpath?:
+      | { ok: false }
+      | {
+          ok: true;
+          path: string;
+        };
+
+    /**
+     * Result returned by `Stat`, using the compiler's file-versus-directory
+     * view.
+     */
+    stat?: "directory" | "file" | "missing";
+  }
+
   /** Successful source-to-source transformation result. */
   export interface ISuccess {
     /** Indicates that transformation completed without diagnostics. */

package/utility/host.go

@@ -307,13 +307,14 @@ func loadUtilityProgram(opts hostOptions) (*driver.Program, []driver.PluginEntry
   defer restoreEnv()
 
   prog, diags, err := driver.LoadProgram(opts.cwd, opts.tsconfig, driver.LoadProgramOptions{
-    ForceEmit:      opts.emit,
-    ForceNoEmit:    opts.noEmit,
-    OutDir:         opts.outDir,
-    SingleThreaded: opts.singleThreaded,
-    Checkers:       opts.checkers,
-    TsgoArgs:       opts.tsgoArgs,
-    FS:             opts.fs,
+    ForceEmit:          opts.emit,
+    ForceNoEmit:        opts.noEmit,
+    OutDir:             opts.outDir,
+    SemanticConfigPath: os.Getenv(driver.SemanticConfigPathEnv),
+    SingleThreaded:     opts.singleThreaded,
+    Checkers:           opts.checkers,
+    TsgoArgs:           opts.tsgoArgs,
+    FS:                 opts.fs,
   })
   if err != nil {
     fmt.Fprintf(opts.stderr, "ttsc utility: %v\n", err)