@ttsc/lint 0.33.0-next.1 → 0.33.0

package/src/createTtscPlugin.ts

@@ -2013,9 +2013,11 @@ function evaluateTtsxConfigPlugins(
 ): ConfigPluginEvaluation {
   const existing = evaluated.get(configPath);
   if (existing !== undefined) return existing;
-  const tempDir = createCanonicalTempDirectory(
-    "ttsc-lint-cfg-",
-    loaderTempBase(configPath),
+  const tempDir = createConfigLoaderTempDirectory(
+    configPath,
+    os.tmpdir(),
+    process.env.TTSC_PLUGIN_RECORD_ROOT,
+    context.projectRoot,
   );
   try {
     linkNearestNodeModules(tempDir, path.dirname(configPath));
@@ -2737,29 +2739,204 @@ function linkNearestNodeModules(tempDir: string, sourceDir: string): void {
 }
 
 /**
- * Picks the parent directory for the ephemeral config-loader tree. The system
- * temp dir is the default, but when it sits on a different volume than the
- * config file (Windows: TEMP on `C:`, project on `D:`) the loader cannot work
- * from there — no single tsconfig `rootDir` spans two volumes and
- * `path.relative` cannot produce a relative import across drives (#305) — so
- * the tree is created under the config's nearest `node_modules/.cache` instead,
- * falling back to the config's own directory when no `node_modules` exists (or
- * its `.cache` cannot be created): any location on the config's volume beats
- * the system temp dir, which is guaranteed to fail. Keeps the system temp dir
- * when the volumes already match.
+ * Creates the typed config evaluator below a stable same-volume cache directory
+ * when a descriptor load has already opened one. The identity directory exists
+ * before descriptor imports are observed, so creating and removing an evaluator
+ * below it leaves the project directory's missing-path witness unchanged. A
+ * moved, aliased, unwritable, or differently mounted identity directory uses
+ * the established loader placement instead. TypeScript-Go needs the generated
+ * loader and the lexical config path on one volume (#305), so a TEMP junction
+ * cannot override the volume of the canonical loader path. Without a suitable
+ * cache, an existing user temp directory outside the config tree is preferred
+ * to writing beside the config. A TEMP path in or above the declared project or
+ * config directory yields to an existing identity store so observed ancestor
+ * metadata remains stable. An independent config evaluation without descriptor
+ * input capture may retain a strict external ancestor as its historical system
+ * temp. No safe same-volume directory is an error.
+ *
+ * @evidence contracts/common.md#principled-implementation Native realpath and the returned canonical child must share the config's lexical volume; a rejected empty child is removed by its physical path. A system temp overlapping a physical project or config ancestor yields to an authoritative identity store, and descriptor-load children retain conservative ancestor handling. Descriptor identities need physical child and config-ancestor checks, and alternate user temp candidates must already exist outside the config tree.
+ * @evidence contracts/common.md#clear-and-simple-design This function owns placement, while the existing canonical creator and nearest-cache selector retain their respective creation and discovery responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Selection uses the descriptor's actual cache root and native filesystem identity, and every accepted fallback satisfies the compiler's lexical-volume requirement without returning a mutable junction spelling.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the preexisting cache preference, TEMP junction and ancestor handling, and explicit failure when no usable same-volume directory exists.
  */
-function loaderTempBase(configPath: string): string {
-  const systemTemp = os.tmpdir();
-  const systemRoot = path.parse(systemTemp).root;
-  const configRoot = path.parse(configPath).root;
-  // A relative config path has no root; "" must not be read as "a volume
-  // other than the system temp's" — it keeps the historical default.
+export function createConfigLoaderTempDirectory(
+  configPath: string,
+  systemTemp: string = os.tmpdir(),
+  recordRoot: string | undefined = process.env.TTSC_PLUGIN_RECORD_ROOT,
+  projectRoot?: string,
+): string {
+  const prefix = "ttsc-lint-cfg-";
+  const configVolume = path.parse(configPath).root;
+  if (configVolume === "")
+    return createCanonicalTempDirectory(prefix, systemTemp);
+
+  const configDir = path.dirname(configPath);
+  const physicalConfigDir = fs.realpathSync.native(configDir);
+  let physicalProjectRoot: string | undefined = physicalConfigDir;
+  if (projectRoot?.trim()) {
+    try {
+      physicalProjectRoot = fs.realpathSync.native(path.resolve(projectRoot));
+    } catch {
+      physicalProjectRoot = undefined;
+    }
+  }
+  const contains = (ancestor: string, other: string): boolean => {
+    const relative = path.relative(ancestor, other);
+    return (
+      relative === "" ||
+      (relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative))
+    );
+  };
+  const unavailable = (error: unknown): boolean =>
+    ["EACCES", "EPERM", "ENOENT", "ENOTDIR", "EROFS"].includes(
+      (error as NodeJS.ErrnoException).code ?? "",
+    );
+  let physicalSystemTemp: string | undefined;
+  try {
+    physicalSystemTemp = fs.realpathSync.native(systemTemp);
+  } catch {
+    // An unavailable system temp can be replaced by an existing safe owner.
+  }
+  const createOnConfigVolume = (parent: string): string | undefined => {
+    let directory: string;
+    try {
+      directory = createCanonicalTempDirectory(prefix, parent);
+    } catch (error) {
+      if (unavailable(error)) return undefined;
+      throw error;
+    }
+    if (
+      path.parse(directory).root.toLowerCase() === configVolume.toLowerCase()
+    ) {
+      return directory;
+    }
+    fs.rmdirSync(directory);
+    return undefined;
+  };
+  const systemTempOnConfigVolume =
+    physicalSystemTemp !== undefined &&
+    path.parse(physicalSystemTemp).root.toLowerCase() ===
+      configVolume.toLowerCase();
+  const systemTempInsideProjectOrConfig =
+    physicalSystemTemp !== undefined &&
+    (physicalProjectRoot === undefined ||
+      contains(physicalProjectRoot, physicalSystemTemp) ||
+      contains(physicalConfigDir, physicalSystemTemp));
+  const systemTempExternalAncestor =
+    physicalSystemTemp !== undefined &&
+    !systemTempInsideProjectOrConfig &&
+    ((physicalProjectRoot !== undefined &&
+      contains(physicalSystemTemp, physicalProjectRoot)) ||
+      contains(physicalSystemTemp, physicalConfigDir));
+  const independentEvaluation = process.env.TTSC_PLUGIN_DESCRIPTOR_LOAD !== "1";
+  if (
+    systemTempOnConfigVolume &&
+    !systemTempInsideProjectOrConfig &&
+    !systemTempExternalAncestor
+  ) {
+    const directory = createOnConfigVolume(systemTemp);
+    if (directory !== undefined) return directory;
+  }
+
+  let preferred: string | undefined;
+  if (recordRoot && path.isAbsolute(recordRoot)) {
+    try {
+      const physicalRoot = fs.realpathSync.native(recordRoot);
+      const identityPath = path.join(recordRoot, "identities");
+      const identityEntry = fs.lstatSync(identityPath);
+      const physicalIdentity = fs.realpathSync.native(identityPath);
+      if (
+        identityEntry.isDirectory() &&
+        !identityEntry.isSymbolicLink() &&
+        path.dirname(physicalIdentity) === physicalRoot &&
+        path.parse(physicalIdentity).root.toLowerCase() ===
+          configVolume.toLowerCase() &&
+        !contains(physicalIdentity, physicalConfigDir)
+      ) {
+        preferred = physicalIdentity;
+      }
+    } catch {
+      // The optional cache placement is unavailable; keep the established one.
+    }
+  }
+  if (preferred !== undefined) {
+    const directory = createOnConfigVolume(preferred);
+    if (directory !== undefined) return directory;
+  }
   if (
-    configRoot === "" ||
-    systemRoot.toLowerCase() === configRoot.toLowerCase()
+    independentEvaluation &&
+    systemTempOnConfigVolume &&
+    systemTempExternalAncestor &&
+    !recordRoot
   ) {
-    return systemTemp;
+    const directory = createOnConfigVolume(systemTemp);
+    if (directory !== undefined) return directory;
+  }
+
+  const nearest = loaderTempBase(configPath);
+  const ambient = [
+    process.env.TMPDIR,
+    process.env.TMP,
+    process.env.TEMP,
+    process.env.LOCALAPPDATA
+      ? path.join(process.env.LOCALAPPDATA, "Temp")
+      : undefined,
+  ];
+  const candidates = nearest === configDir ? ambient : [nearest, ...ambient];
+  const seen = new Set<string>();
+  for (const candidate of candidates) {
+    if (!candidate || !path.isAbsolute(candidate)) continue;
+    let physical: string;
+    try {
+      physical = fs.realpathSync.native(candidate);
+      if (!fs.lstatSync(physical).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (seen.has(physical)) continue;
+    seen.add(physical);
+    if (path.parse(physical).root.toLowerCase() !== configVolume.toLowerCase())
+      continue;
+    if (
+      (nearest === configDir || candidate !== nearest) &&
+      (contains(physical, physicalConfigDir) ||
+        contains(physicalConfigDir, physical))
+    ) {
+      continue;
+    }
+    const directory = createOnConfigVolume(physical);
+    if (directory !== undefined) return directory;
+  }
+  if (
+    independentEvaluation &&
+    systemTempOnConfigVolume &&
+    systemTempExternalAncestor &&
+    recordRoot
+  ) {
+    const directory = createOnConfigVolume(systemTemp);
+    if (directory !== undefined) return directory;
   }
+  if (
+    path.parse(physicalConfigDir).root.toLowerCase() ===
+    configVolume.toLowerCase()
+  ) {
+    const directory = createOnConfigVolume(configDir);
+    if (directory !== undefined) return directory;
+  }
+  throw new Error(
+    `@ttsc/lint: no writable temporary directory on ${configVolume} for config ${configPath}; set TEMP, TMP, or TMPDIR to an existing directory on that drive or enable a same-drive ttsc cache`,
+  );
+}
+
+/**
+ * Finds the nearest node_modules cache, falling back to the config directory.
+ * The caller checks the canonical drive before using either path because a
+ * config junction can place that directory on another drive (#305).
+ */
+function loaderTempBase(configPath: string): string {
+  const configRoot = path.parse(configPath).root;
   const nodeModules = findNearestNodeModules(path.dirname(configPath));
   if (!nodeModules) return path.dirname(configPath);
   const base = path.join(nodeModules, ".cache");