ttsc 0.19.2 → 0.20.0

package/src/plugin/internal/buildSourcePlugin.ts

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 import { findNearestGoMod } from "../../compiler/internal/paths";
 
@@ -193,7 +194,7 @@ export function buildSourcePlugin(opts: {
   const { dir, entry, source } = resolveSourceBuildTarget(opts);
   const overlayDirs = [...(opts.overlayDirs ?? findTtscOverlayDirs())].sort();
   const contributors = opts.contributors ?? [];
-  const goBinary = resolveGoCompiler(env);
+  const goBinary = resolveGoToolForBuild(resolveGoCompiler(env), env, dir);
   ensureExecutableGoToolchain(goBinary);
   const key = computeCacheKey({
     contributors,
@@ -267,7 +268,8 @@ function compileSourcePlugin(opts: {
             .join(", ")}`;
     process.stderr.write(
       `ttsc: building ${opts.label} "${opts.pluginName}" from ${opts.source}${extra} ` +
-        `(this runs once per cache key and can take several minutes on a cold Go cache)\n`,
+        `(this runs once per cache key and can take several minutes on a cold Go cache) ` +
+        `See https://ttsc.dev/docs/ttsc/compile#plugin-cache to persist it across builds.\n`,
     );
   }
 
@@ -1462,6 +1464,13 @@ function sourceBuildWorkspaceReplacements(
  * `/` (the workspace convention) and then delegate to
  * {@link autoQuoteGoModToken}, which mirrors `modfile.AutoQuote`.
  *
+ * Separator normalization is itself a quoting trigger. A Windows UNC
+ * (`\\server\share\...`) or extended-length (`\\?\C:\...`) path normalizes into
+ * a token that starts with `//`, and the modfile lexer reads `//` as a line
+ * comment wherever it appears. Emitted bare, such a token turns its whole
+ * `use`/`replace` line into a comment: `go` exits 0, reports nothing, and the
+ * overlay module simply disappears from the workspace.
+ *
  * Exported for unit tests.
  */
 export function formatGoWorkPath(p: string): string {
@@ -1472,9 +1481,9 @@ export function formatGoWorkPath(p: string): string {
  * Quote `token` for a `go.mod`/`go.work` line exactly as
  * `golang.org/x/mod/modfile`'s `AutoQuote` does: return it unchanged when it is
  * already a clean bare token, otherwise return its Go double-quoted form so the
- * value round-trips through the modfile lexer. A space-free path is therefore
- * emitted byte-for-byte as before; only tokens that would otherwise
- * mis-tokenize are quoted.
+ * value round-trips through the modfile lexer. A clean bare token is therefore
+ * emitted byte-for-byte as before; only tokens that would otherwise be split or
+ * interpreted as comments are quoted.
  *
  * Exported for unit tests.
  */
@@ -1505,11 +1514,11 @@ function mustQuoteGoModToken(s: string): boolean {
       }
       continue;
     }
-    if (!isGoGraphic(ch)) {
+    if (!isGoPrintable(ch)) {
       return true;
     }
   }
-  return s === "" || s === "//" || s === "/*";
+  return s === "" || s.includes("//") || s.includes("/*");
 }
 
 // Mirror `strconv.Quote`: wrap in double quotes, backslash-escape `"` and `\`,
@@ -1562,13 +1571,6 @@ function escapeGoRune(ch: string): string {
   }
 }
 
-// `unicode.IsGraphic`: categories L, M, N, P, S, Zs (all spacing).
-const GO_GRAPHIC_RE = /^[\p{L}\p{M}\p{N}\p{P}\p{S}\p{Zs}]$/u;
-
-function isGoGraphic(ch: string): boolean {
-  return GO_GRAPHIC_RE.test(ch);
-}
-
 // `strconv.IsPrint`: the graphic categories except that the ONLY spacing
 // character is the ASCII space (U+0020); other Unicode spaces are escaped.
 const GO_PRINTABLE_RE = /^[\p{L}\p{M}\p{N}\p{P}\p{S}]$/u;
@@ -1761,24 +1763,85 @@ function goToolchainNotFoundMessage(pluginName: string): string {
   );
 }
 
-function spawnGoTool(
+export function spawnGoTool(
   goBinary: string,
   args: readonly string[],
   options: SpawnSyncOptionsWithStringEncoding,
 ): SpawnSyncReturns<string> {
-  const shell = shouldSpawnGoToolThroughShell(goBinary);
-  // Under shell:true (a Windows .cmd/.bat wrapper) Node does not quote the
-  // command, so a wrapper at a path containing a space would be split by cmd.
-  // Quote it here; the go arguments ttsc passes never contain spaces, and
-  // quoting a space-free path is harmless.
-  return spawnSync(shell ? `"${goBinary}"` : goBinary, [...args], {
-    ...options,
-    shell,
-  });
+  if (process.platform !== "win32") {
+    return spawnSync(goBinary, [...args], options);
+  }
+  const inheritedEnv = options.env ?? process.env;
+  const resolved = resolveWindowsGoTool(
+    goBinary,
+    inheritedEnv,
+    spawnWorkingDirectory(options.cwd),
+  );
+  if (!resolved.wrapper) {
+    return spawnSync(goBinary, [...args], options);
+  }
+  // Preserve the native spawn ENOENT contract before cmd.exe becomes the
+  // actual child process. The callers use that code for the install guidance.
+  if (resolved.location === null) {
+    return spawnSync(goBinary, [...args], options);
+  }
+  const shim = createWindowsGoCommandShim([resolved.location, ...args]);
+  return spawnSync(
+    readWindowsEnvironmentValue(inheritedEnv, "COMSPEC") ??
+      readWindowsEnvironmentValue(process.env, "COMSPEC") ??
+      "cmd.exe",
+    windowsGoCommandArgs(shim.payload),
+    {
+      ...options,
+      env: { ...inheritedEnv, ...shim.environment },
+      shell: false,
+      // The /c payload is already one fully quoted Windows command line.
+      windowsVerbatimArguments: true,
+    },
+  );
 }
 
-function shouldSpawnGoToolThroughShell(goBinary: string): boolean {
-  return process.platform === "win32" && /\.(?:bat|cmd)$/i.test(goBinary);
+/** Build the fixed cmd.exe switch sequence for one already quoted payload. */
+export function windowsGoCommandArgs(payload: string): string[] {
+  return ["/d", "/v:off", "/s", "/c", payload];
+}
+
+function spawnWorkingDirectory(
+  cwd: SpawnSyncOptionsWithStringEncoding["cwd"],
+): string {
+  if (cwd === undefined) return process.cwd();
+  return path.resolve(typeof cwd === "string" ? cwd : fileURLToPath(cwd));
+}
+
+function isWindowsCommandWrapper(location: string): boolean {
+  return process.platform === "win32" && /\.(?:bat|cmd)$/i.test(location);
+}
+
+/** Pass volatile cmd wrapper arguments through one-pass environment expansion. */
+function createWindowsGoCommandShim(args: readonly string[]): {
+  environment: NodeJS.ProcessEnv;
+  payload: string;
+} {
+  const prefix = `TTSC_GO_COMMAND_SHIM_${crypto
+    .randomBytes(8)
+    .toString("hex")
+    .toUpperCase()}_ARG_`;
+  const environment = Object.fromEntries(
+    args.map((arg, index) => [prefix + index, quoteWindowsCommandArg(arg)]),
+  );
+  return {
+    environment,
+    // cmd expands each placeholder exactly once. Percent-shaped text inside an
+    // expanded value is not scanned as a second environment reference.
+    payload: `"${args.map((_, index) => `%${prefix}${index}%`).join(" ")}"`,
+  };
+}
+
+/** Quote one argv value for the Windows command-line parser used by cmd. */
+function quoteWindowsCommandArg(arg: string): string {
+  return `"${String(arg)
+    .replace(/(\\*)"/g, '$1$1\\"')
+    .replace(/(\\*)$/, "$1$1")}"`;
 }
 
 function goBuildEnv(
@@ -2228,15 +2291,19 @@ export function computeCacheKey(inputs: {
   tsgoVersion: string;
 }): string {
   const env = inputs.env ?? process.env;
+  const goBinary =
+    inputs.goBinary === undefined
+      ? undefined
+      : resolveGoToolForBuild(inputs.goBinary, env, inputs.dir);
   const hash = crypto.createHash("sha256");
   hash.update(`ttsc=${inputs.ttscVersion}\n`);
   hash.update(`tsgo=${inputs.tsgoVersion}\n`);
   hash.update(`platform=${process.platform}/${process.arch}\n`);
   hash.update(`entry=${inputs.entry}\n`);
-  if (inputs.goBinary !== undefined) {
-    hash.update(`go=${resolveGoCompilerIdentity(inputs.goBinary, env)}\n`);
+  if (goBinary !== undefined) {
+    hash.update(`go=${resolveGoCompilerIdentity(goBinary, env, inputs.dir)}\n`);
   }
-  hashGoBuildEnvironment(hash, inputs.goBinary, inputs.dir, env);
+  hashGoBuildEnvironment(hash, goBinary, inputs.dir, env);
   hashExternalGoBuildEnvironment(hash, env);
   hashSourceDirectory(hash, "plugin", inputs.dir);
   for (const [index, dir] of [...(inputs.overlayDirs ?? [])].sort().entries()) {
@@ -2328,23 +2395,42 @@ function isHashableFile(name: string): boolean {
 // content signature (byte size + nanosecond mtime). That signature changes if
 // a long-lived host rewrites the binary in place between calls, so the memo
 // re-derives the identity exactly as the un-memoized code would and the
-// cache-key bytes stay byte-for-byte identical to today. `go version` reads no
-// cwd/custom env (the spawn passes neither), so cwd is not part of the key.
+// cache-key bytes stay byte-for-byte identical to today. The selected compiler
+// path is shared by every build subprocess on Windows, while `go version` uses
+// the same effective cwd and environment as the cache-key `go env` query. The
+// memo key includes that context so an environment-sensitive wrapper cannot
+// lend its version result to another compiler invocation.
 const goCompilerIdentityCache = new Map<string, string>();
 
 function resolveGoCompilerIdentity(
   goBinary: string,
   env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd(),
 ): string {
-  const resolved = resolveExecutableIdentityPath(goBinary, env);
-  const memoKey = goCompilerIdentityMemoKey(goBinary, resolved);
+  const selected = resolveGoToolForBuild(goBinary, env, cwd);
+  const resolved =
+    process.platform === "win32"
+      ? resolveRealPath(selected)
+      : resolveExecutableIdentityPath(selected, env, cwd);
+  const compilerEnv = goBuildEnv(selected, undefined, env);
+  const memoKey = goCompilerIdentityMemoKey(
+    goBinary,
+    resolved,
+    compilerEnv,
+    cwd,
+  );
   if (memoKey !== null) {
     const cached = goCompilerIdentityCache.get(memoKey);
     if (cached !== undefined) {
       return cached;
     }
   }
-  const identity = computeGoCompilerIdentity(goBinary, resolved);
+  const identity = computeGoCompilerIdentity(
+    selected,
+    resolved,
+    compilerEnv,
+    cwd,
+  );
   if (memoKey !== null) {
     goCompilerIdentityCache.set(memoKey, identity);
   }
@@ -2357,21 +2443,38 @@ function resolveGoCompilerIdentity(
 function goCompilerIdentityMemoKey(
   goBinary: string,
   resolved: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
 ): string | null {
   try {
     const stat = fs.statSync(resolved);
-    return `${goBinary}\0${resolved}\0${stat.size}\0${stat.mtimeMs}`;
+    const context = crypto.createHash("sha256");
+    context.update(cwd);
+    for (const [key, value] of Object.entries(env).sort(([left], [right]) =>
+      left === right ? 0 : left < right ? -1 : 1,
+    )) {
+      if (value === undefined) continue;
+      context.update(`\0${key.length}:${key}${value.length}:${value}`);
+    }
+    return `${goBinary}\0${resolved}\0${stat.size}\0${stat.mtimeMs}\0${context.digest("hex")}`;
   } catch {
     return null;
   }
 }
 
-function computeGoCompilerIdentity(goBinary: string, resolved: string): string {
+function computeGoCompilerIdentity(
+  goBinary: string,
+  resolved: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+): string {
   if (!fs.existsSync(resolved)) {
     return "missing";
   }
   const version = spawnGoTool(goBinary, ["version"], {
+    cwd,
     encoding: "utf8",
+    env,
     windowsHide: true,
   });
   const versionText =
@@ -2385,48 +2488,207 @@ function computeGoCompilerIdentity(goBinary: string, resolved: string): string {
 function resolveExecutableIdentityPath(
   binary: string,
   env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd(),
 ): string {
-  if (path.isAbsolute(binary)) {
-    return resolveRealPath(binary);
-  }
-  if (binary.includes(path.sep)) {
-    return resolveRealPath(path.resolve(binary));
-  }
-  for (const dir of readPathEnvironment(env).split(path.delimiter)) {
-    if (dir.length === 0) continue;
-    const candidate = path.join(dir, binary);
-    if (fs.existsSync(candidate)) {
-      return resolveRealPath(candidate);
-    }
-    if (process.platform === "win32") {
-      // Probe every PATHEXT extension, not just `.exe`, so a compiler backed by
-      // a `.cmd`/`.bat` wrapper resolves to its real file and is hashed into the
-      // cache key. Otherwise the wrapper reads as "missing" and a change to it
-      // would not invalidate the cached plugin binary.
-      for (const ext of windowsExecutableExtensions(env)) {
-        const executable = `${candidate}${ext}`;
-        if (fs.existsSync(executable)) {
-          return resolveRealPath(executable);
-        }
+  const resolved = findExecutablePath(binary, env, cwd);
+  return resolved === null ? binary : resolveRealPath(resolved);
+}
+
+/** Pin Windows PATH and command-wrapper lookup to one build-wide target. */
+function resolveGoToolForBuild(
+  binary: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+): string {
+  if (process.platform !== "win32") return binary;
+  return resolveWindowsGoTool(binary, env, cwd).location ?? binary;
+}
+
+function findExecutablePath(
+  binary: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+): string | null {
+  for (const candidate of executableSearchBases(binary, env, cwd)) {
+    const resolved = findExecutableCandidate(candidate, env);
+    if (resolved !== null) return resolved;
+  }
+  return null;
+}
+
+interface IWindowsGoToolResolution {
+  location: string | null;
+  wrapper: boolean;
+}
+
+/** Preserve libuv's native target before falling back to cmd/bat wrappers. */
+function resolveWindowsGoTool(
+  binary: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+): IWindowsGoToolResolution {
+  const candidates = executableSearchBases(binary, env, cwd);
+  if (isWindowsCommandWrapper(binary)) {
+    return {
+      location: candidates.find(isExecutableFile) ?? null,
+      wrapper: true,
+    };
+  }
+
+  const hasExtension = windowsFileNameHasExtension(binary);
+  for (const candidate of candidates) {
+    if (hasExtension && isExecutableFile(candidate)) {
+      return { location: candidate, wrapper: false };
+    }
+    for (const extension of [".com", ".exe"]) {
+      const executable = candidate + extension;
+      if (isExecutableFile(executable)) {
+        return { location: executable, wrapper: false };
+      }
+    }
+  }
+
+  const wrapperExtensions = windowsExecutableExtensions(env).filter((ext) =>
+    /\.(?:bat|cmd)$/i.test(ext),
+  );
+  for (const candidate of candidates) {
+    for (const extension of wrapperExtensions) {
+      const executable = candidate + extension;
+      if (isExecutableFile(executable)) {
+        return { location: executable, wrapper: true };
       }
     }
   }
-  return binary;
+  return { location: null, wrapper: false };
+}
+
+function executableSearchBases(
+  binary: string,
+  env: NodeJS.ProcessEnv,
+  cwd: string,
+): string[] {
+  if (path.isAbsolute(binary)) return [binary];
+  if (hasPathQualifier(binary)) return [path.resolve(cwd, binary)];
+
+  const directories =
+    process.platform === "win32"
+      ? splitWindowsSearchPath(readPathEnvironment(env))
+          // libuv skips only genuinely empty slices. A quoted-empty slice
+          // survives that check, unquotes to "", and therefore names cwd.
+          .filter((entry) => entry.length > 0)
+          .map(unquoteWindowsSearchEntry)
+      : readPathEnvironment(env).split(path.delimiter);
+  const noDefaultCurrentDirectory =
+    process.platform === "win32"
+      ? readWindowsEnvironmentValue(
+          process.env,
+          "NoDefaultCurrentDirectoryInExePath",
+        )
+      : undefined;
+  if (process.platform === "win32" && noDefaultCurrentDirectory === undefined) {
+    directories.unshift(cwd);
+  }
+  return directories.map((dir) => path.resolve(cwd, dir, binary));
+}
+
+function findExecutableCandidate(
+  candidate: string,
+  env: NodeJS.ProcessEnv,
+): string | null {
+  if (isExecutableFile(candidate)) return candidate;
+  if (process.platform !== "win32") return null;
+  // Probe every PATHEXT extension, not just `.exe`, so a compiler backed by a
+  // `.cmd`/`.bat` wrapper is both launched correctly and hashed into the cache
+  // key. Otherwise the wrapper reads as missing and changes do not invalidate
+  // the cached plugin binary.
+  for (const ext of windowsExecutableExtensions(env)) {
+    const executable = `${candidate}${ext}`;
+    if (isExecutableFile(executable)) return executable;
+  }
+  return null;
+}
+
+function isExecutableFile(location: string): boolean {
+  try {
+    return fs.statSync(location).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function hasPathQualifier(location: string): boolean {
+  return (
+    location.includes(path.sep) ||
+    (process.platform === "win32" &&
+      (location.includes("/") || /^[a-zA-Z]:/.test(location)))
+  );
+}
+
+function windowsFileNameHasExtension(location: string): boolean {
+  const name = path.basename(location);
+  const dot = name.indexOf(".");
+  return dot >= 0 && dot < name.length - 1;
+}
+
+function splitWindowsSearchPath(value: string): string[] {
+  const entries: string[] = [];
+  let start = 0;
+  let quote = "";
+  for (let index = 0; index < value.length; index++) {
+    const character = value[index]!;
+    if (quote !== "") {
+      if (character === quote) quote = "";
+    } else if ((character === '"' || character === "'") && index === start) {
+      quote = character;
+    } else if (character === ";") {
+      entries.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  entries.push(value.slice(start));
+  return entries;
+}
+
+function unquoteWindowsSearchEntry(location: string): string {
+  const first = location[0];
+  const withoutFirst =
+    first === '"' || first === "'" ? location.slice(1) : location;
+  const last = withoutFirst[withoutFirst.length - 1];
+  return last === '"' || last === "'"
+    ? withoutFirst.slice(0, -1)
+    : withoutFirst;
 }
 
 function windowsExecutableExtensions(
   env: NodeJS.ProcessEnv = process.env,
 ): readonly string[] {
-  const pathext = env.PATHEXT;
+  const pathext = readWindowsEnvironmentValue(env, "PATHEXT");
   const raw = pathext && pathext.length > 0 ? pathext : ".COM;.EXE;.BAT;.CMD";
-  return raw
-    .split(";")
-    .map((ext) => ext.trim().toLowerCase())
+  return splitWindowsSearchPath(raw)
+    .map(unquoteWindowsSearchEntry)
+    .map((ext) => ext.toLowerCase())
     .filter((ext) => ext.length > 0);
 }
 
 function readPathEnvironment(env: NodeJS.ProcessEnv = process.env): string {
-  return env.PATH ?? env.Path ?? "";
+  return process.platform === "win32"
+    ? (readWindowsEnvironmentValue(env, "PATH") ??
+        readWindowsEnvironmentValue(process.env, "PATH") ??
+        "")
+    : (env.PATH ?? "/usr/bin:/bin");
+}
+
+function readWindowsEnvironmentValue(
+  env: NodeJS.ProcessEnv,
+  name: string,
+): string | undefined {
+  const exact = env[name];
+  if (exact !== undefined) return exact;
+  const normalized = name.toLowerCase();
+  const key = Object.keys(env)
+    .filter((candidate) => candidate.toLowerCase() === normalized)
+    .sort()[0];
+  return key === undefined ? undefined : env[key];
 }
 
 function resolveRealPath(location: string): string {

package/src/plugin/internal/loadProjectPlugins.ts

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 
 import { findNearestGoMod } from "../../compiler/internal/paths";
+import { readJsonFile } from "../../compiler/internal/project/readConfigJson";
 import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
 import type { ITtscPlugin } from "../../structures/ITtscPlugin";
 import type { ITtscPluginContributor } from "../../structures/ITtscPluginContributor";
@@ -541,11 +542,17 @@ function findNearestPackageJson(location: string): string | undefined {
   }
 }
 
+/**
+ * Read a package manifest, or `undefined` when the file is absent or is not a
+ * JSON object. A malformed manifest throws naming the file: these are usually
+ * files the user did not author, which makes an unattributed `JSON.parse`
+ * message worse here than anywhere else.
+ */
 function readPackageManifest(file: string): PackageManifest | undefined {
   if (!fs.existsSync(file)) {
     return undefined;
   }
-  const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
+  const parsed = readJsonFile(file);
   return isRecord(parsed) ? (parsed as PackageManifest) : undefined;
 }
 
@@ -1157,7 +1164,78 @@ function selectExportTarget(exportsField: unknown, subpath: string): unknown {
     // Conditions object: the whole value is the `.` target.
     return subpath === "." ? exportsField : undefined;
   }
-  return subpath in record ? record[subpath] : undefined;
+  if (
+    Object.prototype.hasOwnProperty.call(record, subpath) &&
+    !subpath.includes("*") &&
+    !subpath.endsWith("/")
+  ) {
+    return record[subpath];
+  }
+  const patterns = Object.keys(record)
+    .filter((key) => exportPatternReplacement(key, subpath) !== undefined)
+    .sort(compareExportPatternKeys);
+  if (patterns.length === 0) {
+    return undefined;
+  }
+  const pattern = patterns[0]!;
+  return substituteExportTarget(
+    record[pattern],
+    exportPatternReplacement(pattern, subpath)!,
+  );
+}
+
+/** Capture the middle of one valid single-star exports key. */
+function exportPatternReplacement(
+  pattern: string,
+  subpath: string,
+): string | undefined {
+  const star = pattern.indexOf("*");
+  if (
+    !pattern.startsWith("./") ||
+    star === -1 ||
+    pattern.indexOf("*", star + 1) !== -1
+  ) {
+    return undefined;
+  }
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (
+    subpath.length < pattern.length ||
+    !subpath.startsWith(prefix) ||
+    !subpath.endsWith(suffix)
+  ) {
+    return undefined;
+  }
+  return subpath.slice(prefix.length, subpath.length - suffix.length);
+}
+
+/** Node exports patterns rank longer prefixes, then longer full keys, first. */
+function compareExportPatternKeys(left: string, right: string): number {
+  const leftPrefix = left.indexOf("*");
+  const rightPrefix = right.indexOf("*");
+  if (leftPrefix !== rightPrefix) {
+    return rightPrefix - leftPrefix;
+  }
+  return right.length - left.length;
+}
+
+/** Substitute the selected pattern capture into every string target branch. */
+function substituteExportTarget(target: unknown, replacement: string): unknown {
+  if (typeof target === "string") {
+    return target.split("*").join(replacement);
+  }
+  if (Array.isArray(target)) {
+    return target.map((entry) => substituteExportTarget(entry, replacement));
+  }
+  if (typeof target !== "object" || target === null) {
+    return target;
+  }
+  return Object.fromEntries(
+    Object.entries(target).map(([condition, value]) => [
+      condition,
+      substituteExportTarget(value, replacement),
+    ]),
+  );
 }
 
 /** True when condition key `condition` appears anywhere in a (nested) target. */

package/src/structures/ITtscCompilerTransformation.ts

@@ -48,6 +48,23 @@ export namespace ITtscCompilerTransformation {
 
     /** The project tsconfig followed by its `extends` ancestry. */
     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.
+     *
+     * 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.
+     */
+    candidates?: Record<string, string[]>;
   }
 
   /** Successful source-to-source transformation result. */

package/src/structures/internal/ITtscParsedProjectConfig.ts

@@ -3,6 +3,8 @@ import type { ITtscProjectIdentity } from "./ITtscProjectIdentity";
 
 /** Resolved project config subset used inside the ttsc host. */
 export interface ITtscParsedProjectConfig {
+  /** Every resolved tsconfig/jsconfig in the inherited `extends` chain. */
+  configPaths: readonly string[];
   /** Compiler options after extends inheritance has been applied. */
   compilerOptions: {
     /** Absolute output directory when configured. */