ttsc 0.30.4 → 0.31.0

package/src/compiler/internal/EmitOwnershipIndex.ts

@@ -0,0 +1,254 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { createFilesystemPathIdentityContext } from "../../internal/pathIdentity/createFilesystemPathIdentityContext";
+import { isOutsideRelativePath } from "./isOutsideRelativePath";
+
+/**
+ * Match a source to actual compiler-written JavaScript using producer
+ * provenance.
+ *
+ * Keys are absolute writer paths. Source arrays contain physical coordinates
+ * established by the producer owner, not lexical names resolved again after
+ * compilation. Native hosts use their input ledger; external compiler adapters
+ * own their observed-program, output-rule and stability premises. Empty source
+ * arrays and multiple owners are unknown ownership. A missing record is
+ * legacy/unavailable; an authoritative empty record means no outputs. Neither
+ * filename layout nor source maps supply missing proof.
+ *
+ * Source-content freshness belongs to the generation owner. An owned output
+ * that disappears remains owned, so its reader reports that failure by name.
+ * Output coordinates use one native identity transaction to compare actual
+ * writer aliases; captured source coordinates are never resolved again.
+ *
+ * @evidence contracts/common.md#principled-implementation The producer owner associates its eligible sources with actual writes under its documented observation premises; captured physical coordinates establish ownership independently of filename precedence or source-map settings.
+ * @evidence contracts/common.md#clear-and-simple-design One source index replaces forward layout, inverse filename buckets and map parsing with the actual producing build's associations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing, incomplete or ambiguous provenance cannot be converted to ownership by extension order, matching names or newer source-map content.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs define writer/source coordinates, empty and missing states, and freshness ownership; properties carry only native documentation.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Construction processes recorded output/source associations, normalizes source coordinate text, resolves output identities and builds source/output Sets. Native identity capability observations and proof-gap formatting remain costs of construction; queries reuse those maps instead of rescanning output trees.
+ * @evidence contracts/performance.md#reuse-equivalent-work One constructed index shares captured associations across queries, while each query resolves its current source target. Continued source-content/generation validity remains the producing build owner's responsibility, and a new build needs a new index.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The instance retains source/output Sets, root strings and proof-gap reasons until its caller discards it. Population and bytes grow with captured associations and path/reason text without a configured byte ceiling; construction-local identity memo state is not stored on the instance, and no query history or independently held native descriptor is acquired.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation Output writer aliases use the shared native filesystem identity resolver, preserving sensitive or unknown missing names; captured physical source coordinates remain distinct from later lexical aliases and normalize only Windows volume-root spelling.
+ */
+export class EmitOwnershipIndex {
+  /** Absolute native directory containing this build's isolated outputs. */
+  public readonly emitDir: string;
+
+  /** Source root retained as build context, without inferring output ownership. */
+  public readonly rootDir: string;
+
+  private readonly bySource = new Map<string, Set<string>>();
+  /** Concrete proof gaps retained for actionable lookup failures. */
+  private readonly unavailableReasons: string[];
+
+  /**
+   * Index one completed build's source associations, detached from input
+   * arrays. Sources are already physical coordinates: resolving them again
+   * could adopt a retargeted alias as if it produced the earlier output. The
+   * optional output record checks complete coverage before runtime user files
+   * enter the tree.
+   */
+  public constructor(props: {
+    /** Native isolated output directory owned by the build. */
+    emitDir: string;
+
+    /** Native source-root context of the completed invocation. */
+    rootDir: string;
+
+    /** Complete relative JavaScript output record, captured before layout links. */
+    outputs?: readonly string[];
+
+    /** Absolute written output to captured physical source paths; [] is unknown. */
+    emittedSources?: Readonly<Record<string, readonly string[]>>;
+
+    /** Observed producer refusal reasons; these never establish ownership. */
+    emittedSourceProofFailures?: Readonly<Record<string, string>>;
+  }) {
+    // Output spelling is not provenance: the same native writer file can be
+    // named through a case, short-name or directory-link alias. Resolve only
+    // output coordinates here; captured source coordinates stay untouched.
+    const outputIdentity = createFilesystemPathIdentityContext();
+    this.emitDir = outputIdentity.resolve(path.resolve(props.emitDir)).path;
+    this.rootDir = path.resolve(props.rootDir);
+    if (
+      props.emittedSources !== undefined &&
+      (typeof props.emittedSources !== "object" ||
+        props.emittedSources === null ||
+        Array.isArray(props.emittedSources))
+    ) {
+      throw new Error("ttsc: invalid emitted-source provenance record");
+    }
+    const unavailableReasons =
+      props.emittedSources === undefined
+        ? ["the emitting producer supplied no provenance record"]
+        : [];
+    const recorded =
+      props.outputs === undefined
+        ? undefined
+        : new Set(
+            props.outputs.map(
+              (file) =>
+                outputIdentity.resolve(path.resolve(this.emitDir, file)).key,
+            ),
+          );
+    const accounted = new Set<string>();
+    const ownersByOutput = new Map<string, Set<string>>();
+    for (const [output, sources] of Object.entries(
+      props.emittedSources ?? {},
+    )) {
+      if (!path.isAbsolute(output) || !Array.isArray(sources)) {
+        throw new Error("ttsc: invalid emitted-source provenance record");
+      }
+      const identity = outputIdentity.resolve(path.resolve(output));
+      const location = identity.path;
+      if (!isJavaScriptOutput(location)) continue;
+      const relative = path.relative(this.emitDir, location);
+      if (relative === "" || isOutsideRelativePath(relative)) {
+        throw new Error(
+          "ttsc: emitted-source provenance escapes its output directory",
+        );
+      }
+      if (recorded !== undefined && !recorded.has(identity.key)) {
+        throw new Error(
+          "ttsc: emitted-source provenance names an unrecorded output",
+        );
+      }
+      accounted.add(identity.key);
+      const keys = new Set<string>();
+      for (const source of sources) {
+        if (typeof source !== "string" || !path.isAbsolute(source)) {
+          throw new Error(
+            "ttsc: invalid physical source in emitted-source provenance",
+          );
+        }
+        keys.add(physicalSourceKey(source));
+      }
+      const previousOwners = ownersByOutput.get(identity.key);
+      if (previousOwners === undefined) {
+        ownersByOutput.set(identity.key, new Set(keys));
+      } else {
+        const previousSize = previousOwners.size;
+        for (const key of keys) previousOwners.add(key);
+        if (previousSize <= 1 && previousOwners.size > 1) {
+          unavailableReasons.push(
+            `multiple source owners were established across output aliases for ${JSON.stringify(location)}: ${JSON.stringify([...previousOwners])}`,
+          );
+        }
+      }
+      if (keys.size !== 1) {
+        const reason = props.emittedSourceProofFailures?.[output];
+        unavailableReasons.push(
+          keys.size === 0
+            ? `no source owner was established for ${JSON.stringify(location)}${typeof reason === "string" ? `: ${reason}` : ""}`
+            : `multiple source owners were established for ${JSON.stringify(location)}: ${JSON.stringify([...keys])}`,
+        );
+        continue;
+      }
+      const key = keys.values().next().value!;
+      let outputs = this.bySource.get(key);
+      if (outputs === undefined) {
+        outputs = new Set();
+        this.bySource.set(key, outputs);
+      }
+      outputs.add(location);
+    }
+    if (recorded !== undefined) {
+      for (const output of recorded) {
+        if (isJavaScriptOutput(output) && !accounted.has(output))
+          unavailableReasons.push(
+            `written output has no provenance entry: ${JSON.stringify(output)}`,
+          );
+      }
+    }
+    this.unavailableReasons = unavailableReasons;
+  }
+
+  /**
+   * List ordinary JavaScript outputs before virtual-layout user files are
+   * added. Paths are relative to emitDir with slash-separated protocol
+   * spelling. Links are not followed and enumeration failure propagates; this
+   * list checks coverage but cannot independently establish source ownership.
+   *
+   * @evidence contracts/common.md#principled-implementation Nonfollowing enumeration records ordinary JavaScript outputs and propagates failure rather than certifying an incomplete record as absence.
+   * @evidence contracts/common.md#clear-and-simple-design An explicit stack supplies one sorted path list without content parsing or source inference.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable subtrees are not silently omitted and later linked user files cannot become compiler output through a late snapshot.
+   * @evidence contracts/common.md#meaningful-documentation Native prose states capture timing, returned spelling, link handling and the coverage-versus-ownership distinction before tags.
+   * @evidence contracts/performance.md#efficient-algorithms One traversal visits E entries, performs native directory reads and converts relative path text; J output paths are sorted with path-text comparison costs. It reads no output content, but entry/path storage grows with the enumeration.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work This enumeration owns no cross-call sharing or validity protocol; every call observes the current tree. A build owner may retain the returned record for consumers under its capture-timing premise.
+   *
+   * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The path list transfers to the build owner; no retained handle or cache is acquired.
+   *
+   * @evidence contracts/portability.md#os-neutral-implementation Node directory kinds and relative-path grammar own native behavior; only returned protocol paths normalize separators.
+   */
+  public static listOutputs(emitDir: string): string[] {
+    const root = path.resolve(emitDir);
+    const outputs: string[] = [];
+    const stack = [root];
+    while (stack.length !== 0) {
+      const directory = stack.pop()!;
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const location = path.join(directory, entry.name);
+        if (entry.isDirectory()) stack.push(location);
+        else if (entry.isFile() && isJavaScriptOutput(location)) {
+          outputs.push(path.relative(root, location).split(path.sep).join("/"));
+        }
+      }
+    }
+    return outputs.sort();
+  }
+
+  /**
+   * Return the unique output actually written for this current physical source.
+   * Complete provenance excluding it returns null. Missing, incomplete or
+   * ambiguous ownership throws an error naming the source, output directory and
+   * concrete proof gaps. Query aliases are resolved afresh so a retargeted
+   * spelling cannot reuse an earlier ownership answer. Failure to observe the
+   * current physical target propagates.
+   *
+   * @evidence contracts/common.md#principled-implementation Fresh query identity is compared with captured physical source coordinates; only one written output answers and complete exclusion alone permits null.
+   * @evidence contracts/common.md#clear-and-simple-design One source lookup replaces filename inference; unavailable proof is explicit rather than a hidden fallback policy.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Legacy and unknown records cannot gain a unique owner through extension order or a lexical source alias resolved after compilation.
+   * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes exact, absent and error outcomes, plus fresh alias observation from source-content freshness; errors distinguish missing producer metadata, ownerless or ambiguous rows and uncovered written outputs with their native coordinates.
+   * @evidence contracts/performance.md#efficient-algorithms Construction indexes associations and resolves output coordinates in one memoized native identity transaction, including native capability queries where required; path normalization, alias merging and proof-gap text costs accompany it. Missing suffixes can add ancestor and case-observation work. A successful query resolves source identity and performs one map lookup without scanning outputs or source maps; unavailable errors format retained reason text rather than rereading the output tree.
+   * @evidence contracts/performance.md#reuse-equivalent-work A completed build's captured associations serve all queries while aliases stay fresh; another build requires a new index.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources Index storage grows with captured associations and proof-gap path bytes, with no query history or retained native handle; each successful query finishes its native realpath observation synchronously.
+   * @evidence contracts/portability.md#os-neutral-implementation Native realpath resolves current aliases to physical spelling; exact captured names remain distinct when directory case policy changes, without OS-wide lowercase assumptions.
+   */
+  public find(source: string): string | null {
+    if (this.unavailableReasons.length !== 0) {
+      throw new Error(
+        `ttsc: exact emitted-source ownership is unavailable for ${JSON.stringify(path.resolve(source))} in ${JSON.stringify(this.emitDir)}; ${this.unavailableReasons.join("; ")}. Rebuild with supported emit provenance`,
+      );
+    }
+    const physical = fs.realpathSync.native(path.resolve(source));
+    const outputs = this.bySource.get(physicalSourceKey(physical));
+    if (outputs === undefined) return null;
+    if (outputs.size !== 1) {
+      throw new Error(
+        `ttsc: emitted-source ownership is ambiguous for ${JSON.stringify(physical)}: ${JSON.stringify([...outputs])}`,
+      );
+    }
+    return outputs.values().next().value!;
+  }
+}
+
+/** JavaScript-bearing outputs, excluding maps and declaration artifacts. */
+function isJavaScriptOutput(file: string): boolean {
+  return [".js", ".jsx", ".mjs", ".cjs"].includes(
+    path.extname(file).toLowerCase(),
+  );
+}
+
+/**
+ * Key an already physical coordinate without revisiting its alias or folding
+ * directory-sensitive names. Only Windows volume-root spelling is normalized,
+ * matching the native identity resolver's root convention.
+ */
+function physicalSourceKey(file: string): string {
+  const location = path.normalize(file);
+  if (process.platform !== "win32") return location;
+  const root = path.parse(location).root;
+  return root.toLowerCase() + location.slice(root.length);
+}

package/src/compiler/internal/PrivateCompilerOutput.ts

@@ -0,0 +1,330 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
+import type { RunBuildOptions } from "./build/RunBuildOptions";
+import { privateRuntimeRootDir } from "./build/privateRuntimeRootDir";
+import { isOutsideRelativePath } from "./isOutsideRelativePath";
+
+/**
+ * Compiler destinations and artifact translation for a single in-memory API
+ * request. Native options retain distinct JavaScript, declaration, bundle and
+ * incremental coordinates while all actual writes belong to one private tree.
+ *
+ * @evidence contracts/common.md#principled-implementation Destination translation and returned-artifact translation share one inverse mapping, preserving original public paths while native writes use private paths.
+ * @evidence contracts/common.md#clear-and-simple-design This namespace groups one API output policy; shared build execution consumes its destination record without owning API artifact keys.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Compiler-supported destinations are used instead of foreign filesystem interception or deleting caller artifacts after a write.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes private actual writes from public artifact locations; operation comments document relative map and incremental path ownership.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The namespace groups operations; its path-owning members document the native boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace chooses no processing strategy independent of its members.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace retains no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The API call owns the private directory lifetime.
+ */
+export namespace PrivateCompilerOutput {
+  /**
+   * Relocate each compiler destination independently. Directory mappings retain
+   * the compiler's per-source layout; exact mappings keep bundle and
+   * incremental names independent of that layout. A private explicit build-info
+   * path avoids inferred paths above outDir for deeply nested rootDir values.
+   * Independent checks use another state file so diagnostic recovery cannot
+   * overwrite or masquerade as an emitted API artifact. Only a newly added
+   * outDir needs private root pinning. Relocating a configured outDir retains
+   * native inferred layout and its configuration diagnostics.
+   *
+   * @evidence contracts/common.md#principled-implementation Separate native destinations have inverse mappings to original artifact locations. Only originally source-adjacent emission receives root pinning; configured outDir retains native inferred layout and diagnostics. Inferred state follows pinned outputpaths.GetBuildInfoFileName config/rootDir/outDir rules; explicit private state prevents upward escapes and independent checks use a separate non-artifact destination.
+   * @evidence contracts/common.md#clear-and-simple-design One request-local mapping joins destination selection and artifact translation, preserving bundle/declaration distinctions at the API boundary.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Output destination options preserve incremental checking and separate bundle/declaration output instead of disabling them or cleaning caller paths after publication.
+   * @evidence contracts/common.md#meaningful-documentation Native prose explains path ownership, independent output kinds and why inferred incremental metadata needs an explicit private location.
+   * @evidence contracts/portability.md#os-neutral-implementation Node path resolution and relative paths preserve native volume boundaries and separators; protocol text normalizes host separators only.
+   * @evidence contracts/performance.md#efficient-algorithms At most four destination mappings are allocated. Native path resolution, root-relative inference and each inverse lookup operate on a bounded number of path strings and cost their actual text lengths; no caller tree is traversed.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each request observes new compiler input and owns its output; no cross-request result cache is introduced.
+   * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Mapping and returned text are request-local data; compileProjectInMemory owns acquisition and finally removal of the private tree.
+   */
+  export function create(
+    project: ITtscParsedProjectConfig,
+    directory: string,
+  ): {
+    /** Compiler destinations used only within the owning temporary tree. */
+    destinations: NonNullable<RunBuildOptions["privateOutputDestinations"]>;
+
+    /** Pin layout only when adding an outDir to an originally adjacent emit. */
+    pinInferredRootDir: boolean;
+
+    /** Map a captured native output path back to its original artifact location. */
+    originalPath: (file: string) => string;
+  } {
+    const options = project.compilerOptions;
+    const mappings: {
+      privatePath: string;
+      originalPath: string;
+      kind: "directory" | "file" | "bundle";
+    }[] = [];
+    const relocate = (
+      name: string,
+      original: string,
+      kind: "directory" | "file" | "bundle",
+    ): string => {
+      const privatePath = path.join(
+        directory,
+        name,
+        ...(kind === "directory" ? [] : [path.basename(original)]),
+      );
+      mappings.push({ privatePath, originalPath: original, kind });
+      return privatePath;
+    };
+    const outFile =
+      typeof options.outFile === "string" ? options.outFile : undefined;
+    const sourceRoot = privateRuntimeRootDir(
+      project.root,
+      options.rootDir,
+      options.composite,
+    );
+    const destinations: NonNullable<
+      RunBuildOptions["privateOutputDestinations"]
+    > = {
+      outDir:
+        outFile !== undefined && options.outDir === undefined
+          ? null
+          : relocate("javascript", options.outDir ?? sourceRoot, "directory"),
+      declarationDir:
+        typeof options.declarationDir === "string"
+          ? relocate("declarations", options.declarationDir, "directory")
+          : null,
+      outFile:
+        outFile !== undefined ? relocate("bundle", outFile, "bundle") : null,
+    };
+    if (
+      options.incremental === true ||
+      options.composite === true ||
+      typeof options.tsBuildInfoFile === "string"
+    ) {
+      let original =
+        typeof options.tsBuildInfoFile === "string"
+          ? options.tsBuildInfoFile
+          : undefined;
+      if (original === undefined) {
+        const configStem = removeCompilerExtension(project.path);
+        original =
+          options.outDir !== undefined
+            ? path.resolve(
+                options.outDir,
+                typeof options.rootDir === "string"
+                  ? path.relative(options.rootDir, configStem)
+                  : path.basename(configStem),
+              ) + ".tsbuildinfo"
+            : configStem + ".tsbuildinfo";
+      }
+      destinations.tsBuildInfoFile = relocate("state", original, "file");
+      destinations.diagnosticsTsBuildInfoFile = path.join(
+        directory,
+        "diagnostics",
+        "state.tsbuildinfo",
+      );
+    }
+    return {
+      destinations,
+      pinInferredRootDir:
+        options.outDir === undefined && destinations.outDir !== null,
+      originalPath(file) {
+        for (const mapping of mappings) {
+          if (mapping.kind === "file") {
+            if (file === mapping.privatePath) return mapping.originalPath;
+          } else if (mapping.kind === "bundle") {
+            if (file === mapping.privatePath) return mapping.originalPath;
+            const privateStem = removeCompilerExtension(mapping.privatePath);
+            if (file.startsWith(privateStem + "."))
+              return (
+                removeCompilerExtension(mapping.originalPath) +
+                file.slice(privateStem.length)
+              );
+          } else {
+            const relative = path.relative(mapping.privatePath, file);
+            if (!isOutsideRelativePath(relative))
+              return path.join(mapping.originalPath, relative);
+          }
+        }
+        return file;
+      },
+    };
+  }
+
+  /**
+   * Return all captured compiler artifacts at their original API keys. Source
+   * maps without compiler-owned sourceRoot/mapRoot need their relative sources
+   * re-based from the private destination to the original destination. Explicit
+   * roots already give sources their independent compiler-defined base. Only
+   * the final compiler map trailer is translated; similar authored text inside
+   * a multiline literal remains source text.
+   *
+   * Build information is identified by its selected path, including arbitrary
+   * extensions. Recovery-only state is excluded by path; actual emitted state
+   * remains an artifact even when the compiler also reports errors.
+   *
+   * @evidence contracts/common.md#principled-implementation Inverse destination mapping restores original keys as own data properties, including names inherited from Object.prototype. Maps without explicit sourceRoot/mapRoot rebase source paths through their private and original directories, preserving remote URLs and the pinned native generator's raw file-URL convention for different Windows roots without percent decoding filename data. Build-info source/option paths rebase similarly while special library names remain compiler identifiers. Only the separate check/recovery state is omitted; actual emission state and partial outputs remain captured.
+   * @evidence contracts/common.md#clear-and-simple-design One request-local mapping joins destination selection and artifact translation, preserving bundle/declaration distinctions at the API boundary.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Output destination options preserve incremental checking and separate bundle/declaration output instead of disabling them or cleaning caller paths after publication.
+   * @evidence contracts/common.md#meaningful-documentation Native prose explains path ownership, independent output kinds and why inferred incremental metadata needs an explicit private location.
+   * @evidence contracts/portability.md#os-neutral-implementation Node path resolution and relative paths preserve native volume boundaries and separators; protocol text normalizes host separators only.
+   * @evidence contracts/performance.md#efficient-algorithms The iterative walk visits E private directory entries, sorts F file paths with path-text comparison costs and reads B emitted bytes once. Map/state JSON parsing, translation and serialization cost their actual text and record sizes; retained output grows with B and the path keys.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each request observes new compiler input and owns its output; no cross-request result cache is introduced.
+   * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Mapping and returned text are request-local data; compileProjectInMemory owns acquisition and finally removal of the private tree.
+   */
+  export function read(
+    project: ITtscParsedProjectConfig,
+    directory: string,
+    originalPath: (file: string) => string,
+    buildInfoFile?: string,
+    diagnosticState?: string,
+  ): Record<string, string> {
+    const output: Record<string, string> = {};
+    for (const file of listFiles(directory)) {
+      if (file === diagnosticState) continue;
+      const original = originalPath(file);
+      const relative = path.relative(project.root, original);
+      const key = pathToKey(
+        isOutsideRelativePath(relative) ? original : relative,
+      );
+      let text = fs.readFileSync(file, "utf8");
+      const rebaseMap = (value: string): string => {
+        const map = JSON.parse(value) as {
+          sources?: string[];
+          sourceRoot?: string;
+        };
+        if (
+          !project.compilerOptions.sourceRoot &&
+          !project.compilerOptions.mapRoot &&
+          Array.isArray(map.sources)
+        )
+          map.sources = map.sources.map((source) => {
+            if (
+              /^[a-z][a-z0-9+.-]*:/i.test(source) &&
+              !source.startsWith("file:")
+            )
+              return source;
+            // Native tspath.GetRelativePathToDirectoryOrUrl prefixes disk paths
+            // without URL encoding; percent escapes remain literal filename data.
+            const nativeFile =
+              source.startsWith("file:///") &&
+              /^[A-Za-z]:\//.test(source.slice(8))
+                ? source.slice(8)
+                : source.startsWith("file://")
+                  ? source.slice(7)
+                  : undefined;
+            const resolved =
+              nativeFile ?? path.resolve(path.dirname(file), source);
+            const relative = path.relative(path.dirname(original), resolved);
+            const normalized = pathToKey(relative);
+            return path.isAbsolute(relative)
+              ? (normalized.startsWith("/") ? "file://" : "file:///") +
+                  normalized
+              : normalized;
+          });
+        return JSON.stringify(map);
+      };
+      if (file !== buildInfoFile && file.endsWith(".map"))
+        text = rebaseMap(text);
+      else if (file !== buildInfoFile) {
+        text = text.replace(
+          /((?:^|\n)\/\/#[ \t]*sourceMappingURL=data:application\/json;base64,)([^\s]+)(?=\s*$)/,
+          (_match, prefix: string, payload: string) =>
+            prefix +
+            Buffer.from(
+              rebaseMap(Buffer.from(payload, "base64").toString("utf8")),
+            ).toString("base64"),
+        );
+        if (project.compilerOptions.mapRoot)
+          text = text.replace(
+            /((?:^|\n)\/\/#[ \t]*sourceMappingURL=)([^\s]+)(?=\s*$)/,
+            (match, prefix: string, url: string) => {
+              if (/^(?:[a-z]+:|\/)/i.test(url)) return match;
+              return (
+                prefix +
+                encodeURI(
+                  pathToKey(
+                    path.relative(
+                      path.dirname(original),
+                      path.resolve(path.dirname(file), decodeURI(url)),
+                    ),
+                  ),
+                )
+              );
+            },
+          );
+      } else {
+        const state = JSON.parse(text) as {
+          fileNames?: string[];
+          options?: Record<string, unknown>;
+        };
+        const rebase = (value: string): string =>
+          pathToKey(
+            path.relative(
+              path.dirname(original),
+              originalPath(path.resolve(path.dirname(file), value)),
+            ),
+          );
+        if (Array.isArray(state.fileNames))
+          state.fileNames = state.fileNames.map((file) =>
+            /^lib\.[^/\\]+\.d\.ts$/.test(file) ? file : rebase(file),
+          );
+        if (state.options !== undefined)
+          for (const name of [
+            "outDir",
+            "outFile",
+            "declarationDir",
+            "tsBuildInfoFile",
+            "rootDir",
+          ])
+            if (typeof state.options[name] === "string") {
+              if (typeof project.compilerOptions[name] !== "string")
+                delete state.options[name];
+              else state.options[name] = rebase(state.options[name]);
+            }
+        text = JSON.stringify(state);
+      }
+      Object.defineProperty(output, key, {
+        value: text,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+      });
+    }
+    return output;
+  }
+
+  /**
+   * Match pinned tspath.RemoveFileExtension, including compound declaration
+   * suffixes.
+   */
+  function removeCompilerExtension(file: string): string {
+    return file.replace(
+      /\.(?:d\.(?:ts|mts|cts)|mjs|mts|cjs|cts|ts|js|tsx|jsx|json)$/,
+      "",
+    );
+  }
+
+  /** Recursively list all files under `directory`, sorted for stable output. */
+  function listFiles(directory: string): string[] {
+    const out: string[] = [];
+    const pending = [directory];
+    while (pending.length !== 0) {
+      const current = pending.pop()!;
+      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        const location = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          pending.push(location);
+        } else if (entry.isFile()) {
+          out.push(location);
+        }
+      }
+    }
+    return out.sort();
+  }
+
+  /**
+   * Convert native separators, while retaining literal POSIX backslashes, for
+   * output keys.
+   */
+  function pathToKey(file: string): string {
+    return file.replaceAll(path.sep, "/");
+  }
+}