ttsc 0.31.6 → 0.32.1

package/src/launcher/internal/runTtsx.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 
 import { resolveTsgo } from "../../compiler/internal/resolveTsgo";
 import { E2ETrace } from "../../internal/E2ETrace";
+import { TtsxNodeOptions } from "../../internal/TtsxNodeOptions";
 import { TtsxEntryOptions } from "./TtsxEntryOptions";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { parseTtsxCLI } from "./parseTtsxCLI";
@@ -243,9 +244,13 @@ async function runJavaScriptEntry(
   ];
   const env: NodeJS.ProcessEnv = {
     ...process.env,
-    NODE_OPTIONS: appendNodeOption(
-      process.env.NODE_OPTIONS,
-      `--require ${JSON.stringify(path.join(__dirname, "..", "..", "register.js"))}`,
+    // ttsc's own helpers run with what the user passed (#1740).
+    ...TtsxNodeOptions.give(
+      process.env,
+      appendNodeOption(
+        process.env.NODE_OPTIONS,
+        `--require ${JSON.stringify(path.join(__dirname, "..", "..", "register.js"))}`,
+      ),
     ),
     ...(parsed.binary !== undefined
       ? { TTSC_TSGO_BINARY: path.resolve(cwd, parsed.binary) }
@@ -324,12 +329,16 @@ async function runPreparedEntry(
     ];
     const runtimeEnv: NodeJS.ProcessEnv = {
       ...process.env,
-      NODE_OPTIONS: appendNodeOption(
-        prependNodeOption(
-          process.env.NODE_OPTIONS,
-          `--require ${JSON.stringify(path.join(__dirname, "runtimeOwnerPreload.js"))}`,
+      // ttsc's own helpers run with what the user passed (#1740).
+      ...TtsxNodeOptions.give(
+        process.env,
+        appendNodeOption(
+          prependNodeOption(
+            process.env.NODE_OPTIONS,
+            `--require ${JSON.stringify(path.join(__dirname, "runtimeOwnerPreload.js"))}`,
+          ),
+          `--require ${JSON.stringify(path.join(__dirname, "runtimeHookPreload.js"))}`,
         ),
-        `--require ${JSON.stringify(path.join(__dirname, "runtimeHookPreload.js"))}`,
       ),
       // The compiler this run resolved, which already honours an inherited
       // `TTSC_TSGO_BINARY` when no `--binary` was given.

package/src/launcher/internal/runtime/CommonJsRuntimeSource.ts

@@ -71,16 +71,20 @@ export namespace CommonJsRuntimeSource {
   }
 
   /**
-   * Construct an owned require with local TypeScript extension advertisements.
+   * Construct an owned require sharing the original live extension registry.
    *
-   * @evidence contracts/common.md#principled-implementation createRequire loads through Node's shared CommonJS cache; copied public properties preserve cache/main access, while a copied registry advertises the already-supported source extensions without changing their actual loader.
+   * Node's loader and every native require share this registration object.
+   * Copying it hides later registrations, replacements and deletions from one
+   * side; source-extension advertisement belongs to runtime installation.
+   *
+   * @evidence contracts/common.md#principled-implementation createRequire loads through Node's shared CommonJS cache; copied public properties preserve cache/main access, and the original registry reference preserves the public extension-registration contract across later edits. Missing original metadata falls back to the native registry.
    * @evidence contracts/common.md#clear-and-simple-design The callable and resolve member share one filename anchor; source recovery remains in the configured policy.
-   * @evidence contracts/common.md#prohibited-implementation-shortcuts Extension entries belong to this new function, not Module._extensions or a foreign require; no private loader slot is assigned.
-   * @evidence contracts/common.md#meaningful-documentation Native prose identifies ownership and distinguishes advertisements from actual loading.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Construction assigns only the owned function's properties, adds no extension capability and replaces no foreign handler or private loader slot. Runtime installation separately advertises its supported CommonJS source extensions.
+   * @evidence contracts/common.md#meaningful-documentation Native prose explains why live registry identity is required and assigns advertisement to the installation owner.
    * @evidence contracts/portability.md#os-neutral-implementation The public createRequire API takes the native filename; no OS-name or path-string case heuristic is introduced.
-   * @evidence contracts/performance.md#efficient-algorithms Construction copies public require properties and E extension entries, including their property observations, and creates a native filename-anchored require. Calls delegate native resolution, module evaluation/cache work or the configured resolver; their cost is not bounded by construction or extension count.
+   * @evidence contracts/performance.md#efficient-algorithms Construction copies P public require properties and creates a native filename-anchored require without traversing or allocating another extension registry. Calls delegate native resolution, module evaluation/cache work or the configured resolver; their cost is not bounded by property count.
    * @evidence contracts/performance.md#reuse-equivalent-work Callable loading delegates to Node's CommonJS cache; the configured resolve policy remains a distinct per-call operation, not a cached result of constructing the function.
-   * @evidence contracts/performance.md#bound-retention-and-release-resources The evaluated module owns the returned function, captured filename/native require and copied extension registry. Captured cache/main references share Node or original-require state rather than copying all cached modules; the factory adds no historical module collection or native handle.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources The evaluated module owns the returned function and captured filename/native require. Cache, main and extension-registry references share Node or original-require state; the factory adds no registry copy, historical module collection or native handle.
    */
   export function create(
     original: NodeJS.Require,
@@ -107,9 +111,7 @@ export namespace CommonJsRuntimeSource {
       )) as NodeJS.RequireResolve;
     owned.resolve.paths = native.resolve.paths;
     owned.cache = original.cache ?? native.cache;
-    owned.extensions = { ...(original.extensions ?? native.extensions) };
-    for (const extension of [".ts", ".tsx", ".cts", ".mts"])
-      owned.extensions[extension] = owned.extensions[".js"]!;
+    owned.extensions = original.extensions ?? native.extensions;
     return owned;
   }
 

package/src/launcher/internal/runtime/RuntimeEntrySources.ts

@@ -0,0 +1,57 @@
+import type { RuntimeManifest } from "./RuntimeManifest";
+
+/**
+ * The served source of each entry module a checked entry build emitted,
+ * prepared once.
+ *
+ * A checked entry build's emit is immutable for the run: ttsx prepares it
+ * before the program starts, and a root `ttsc/register` prepares stays
+ * registered (`RuntimeManifestRegistry`). Node 22.15 nevertheless calls the
+ * `load` hook twice for the process entry, and each call read and source-mapped
+ * the same emitted file again (samchon/ttsc#1749). A repeated entry load of one
+ * build's emitted file is answered from its first preparation. A module served
+ * by any other lane, a project build or an isolated emit of a file the program
+ * may rewrite, is prepared on every load as before, and so is a non-entry
+ * module, whose text Node already holds.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an entry module's emitted file of a registered checked build, the registry's immutable premise, is remembered, keyed by that build, so a reused answer is the answer a repeated read would give.
+ * @evidence contracts/common.md#clear-and-simple-design One map per build and one accessor; the caller supplies the preparation it already performs.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Nothing about Node's loader is patched; the hook still answers every call Node makes, and lanes whose source can change are never remembered.
+ * @evidence contracts/common.md#meaningful-documentation Native prose names the repeated call, the immutable entry emit and the lanes left unaffected.
+ * @evidence contracts/portability.md#os-neutral-implementation Files are keyed by the emitted path the build's ownership index returned, under the build object that owns it.
+ * @evidence contracts/performance.md#efficient-algorithms One WeakMap and one map lookup per serve.
+ * @evidence contracts/performance.md#reuse-equivalent-work A repeated entry load of an entry build's emitted file reuses the first preparation.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One served source per entry module, held while the registry keeps its build; a run has one entry and a handful of JavaScript-to-TypeScript boundaries.
+ */
+export namespace RuntimeEntrySources {
+  /**
+   * The served source of entry module `emittedFile` from checked entry build
+   * `manifest`, prepared by `prepare` on its first serve only.
+   *
+   * @evidence contracts/common.md#principled-implementation Only an entry load of a registered checked build's emitted file asks; that emit is immutable for the run, so the first preparation is the answer a repeated one would give.
+   * @evidence contracts/common.md#clear-and-simple-design One lookup or one preparation and insertion.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The caller's own preparation runs unchanged on the first serve.
+   * @evidence contracts/common.md#meaningful-documentation Native prose states which serve prepares.
+   * @evidence contracts/portability.md#os-neutral-implementation Files are keyed by the emitted path the ownership index returned.
+   * @evidence contracts/performance.md#efficient-algorithms One WeakMap and one map lookup, and on the first serve one insertion.
+   * @evidence contracts/performance.md#reuse-equivalent-work A repeated serve returns the first preparation.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources One source per entry module is retained while its build is.
+   */
+  export function serve<Source>(
+    manifest: RuntimeManifest,
+    emittedFile: string,
+    prepare: () => Source,
+  ): Source {
+    let files = served.get(manifest);
+    if (files === undefined) {
+      files = new Map();
+      served.set(manifest, files);
+    }
+    if (files.has(emittedFile)) return files.get(emittedFile) as Source;
+    const source = prepare();
+    files.set(emittedFile, source);
+    return source;
+  }
+}
+
+const served = new WeakMap<RuntimeManifest, Map<string, unknown>>();

package/src/launcher/internal/runtime/RuntimeProjectOwnership.ts

@@ -24,8 +24,8 @@ export namespace RuntimeProjectOwnership {
   const cache = new Map<string, Lookup>();
 
   /**
-   * Whether a physical source path passes through an installed directory.
-   * A linked workspace physically outside that directory remains user source.
+   * Whether a physical source path passes through an installed directory. A
+   * linked workspace physically outside that directory remains user source.
    * Alternate spellings count only when the native lowercase installed spelling
    * resolves to the same physical directory; failed identity reads prove none.
    *
@@ -39,7 +39,7 @@ export namespace RuntimeProjectOwnership {
    * @evidence contracts/performance.md#bound-retention-and-release-resources The synchronous walk retains no handles or historical identities.
    */
   export function isInstalledPackageSource(real: string): boolean {
-    for (let directory = path.dirname(real);;) {
+    for (let directory = path.dirname(real); ; ) {
       if (isInstalledDirectory(directory)) return true;
       const parent = path.dirname(directory);
       if (parent === directory) return false;
@@ -54,8 +54,9 @@ export namespace RuntimeProjectOwnership {
    * Cached walks recheck both candidate files and the native boundary topology.
    * Creating/deleting a config or adding/removing an installed alias therefore
    * cannot retain an earlier consumer or isolated selection. The observer
-   * brackets config candidates and alternate directory identities for descriptor
-   * dependency recording; it does not pin the filesystem during compilation.
+   * brackets config candidates and alternate directory identities for
+   * descriptor dependency recording; it does not pin the filesystem during
+   * compilation.
    *
    * @evidence contracts/common.md#principled-implementation Upward traversal selects the first existing config before the installed boundary. Cache entries retain ordered candidates and their stopping boundary; current candidate and native topology checks establish whether the old selection still applies.
    * @evidence contracts/common.md#clear-and-simple-design The same private predicate serves fresh lookup, cached topology validation and installed-source classification. One directory-keyed cache shares the walked suffix without a second casing policy.
@@ -79,18 +80,28 @@ export namespace RuntimeProjectOwnership {
       if (cached !== undefined) {
         observe(cached.candidates);
         const topologyCurrent =
-          (cached.boundary === undefined || isInstalledDirectory(cached.boundary, observe)) &&
-          cached.candidates.every((candidate) => !isInstalledDirectory(path.dirname(candidate), observe));
+          (cached.boundary === undefined ||
+            isInstalledDirectory(cached.boundary, observe)) &&
+          cached.candidates.every(
+            (candidate) =>
+              !isInstalledDirectory(path.dirname(candidate), observe),
+          );
         const current = nearestExisting(cached.candidates);
         observe(cached.candidates);
         if (topologyCurrent && current === cached.result)
-          return remember(chain, cached.result, cached.candidates, cached.boundary);
+          return remember(
+            chain,
+            cached.result,
+            cached.candidates,
+            cached.boundary,
+          );
         cache.delete(directory);
       }
       chain.push(directory);
       const candidate = path.join(directory, "tsconfig.json");
       observe([candidate]);
-      if (RuntimeFilesystem.isFile(candidate)) return remember(chain, candidate);
+      if (RuntimeFilesystem.isFile(candidate))
+        return remember(chain, candidate);
       const parent = path.dirname(directory);
       if (parent === directory) return remember(chain, null);
       directory = parent;
@@ -108,7 +119,9 @@ export namespace RuntimeProjectOwnership {
     const inputs = [directory, lowercase];
     observe(inputs);
     try {
-      return fs.realpathSync.native(directory) === fs.realpathSync.native(lowercase);
+      return (
+        fs.realpathSync.native(directory) === fs.realpathSync.native(lowercase)
+      );
     } catch {
       return false;
     } finally {

package/src/launcher/internal/runtime/advertiseTypeScriptExtensions.ts

@@ -0,0 +1,25 @@
+/**
+ * Publish the CommonJS source extensions served by the installed runtime hooks.
+ *
+ * Tools such as tsconfig-paths enumerate the process registry before asking
+ * Node to resolve a file, and rechoir checks it before loading a typed config.
+ * A module-local copy cannot satisfy those checks. Add only missing entries
+ * using Node's JavaScript handler; registerHooks still owns source compilation
+ * and existing loader handlers keep their identity. Node probes these entries
+ * after its existing extensions, preserving JavaScript precedence.
+ *
+ * @evidence contracts/common.md#principled-implementation The public require.extensions registry advertises supported CommonJS source loading to consumers that inspect extensions before resolution; absent entries delegate to Node's existing JavaScript handler, which consumes the source supplied by registerHooks.
+ * @evidence contracts/common.md#clear-and-simple-design One installation operation publishes loader capability without adding a second compilation or resolution path.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Only missing public registry entries are added; no foreign handler or method is replaced and no consumer identity affects production behavior. The source suffixes describe the supported CommonJS contract rather than fixture-specific routes.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains why process-wide advertisement is needed, who compiles the source, which handlers remain authoritative and how native precedence is preserved.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Registry updates use JavaScript property semantics without filesystem, path or process arguments; Node's loader owns native resolution.
+ * @evidence contracts/performance.md#efficient-algorithms A fixed set of three CommonJS source extensions requires constant time and space, without scanning modules or files.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This capability publication shares no computed compilation or resolution result.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The caller's process registry retains at most three added references to an existing Node handler for the installed hooks' process lifetime; no handle or task is acquired.
+ */
+export function advertiseTypeScriptExtensions(
+  extensions: NodeJS.RequireExtensions,
+): void {
+  for (const extension of [".ts", ".tsx", ".cts"])
+    extensions[extension] ??= extensions[".js"]!;
+}

package/src/launcher/internal/runtime/commonJsExportNames.ts

@@ -13,7 +13,8 @@ import { realPath } from "./realPath";
  * become resolution origins. Targets are not evaluated. Failed resolution adds
  * no names and leaves the eventual native load to report its error, whereas a
  * reader's ownership error propagates. Root default metadata is retained for
- * the facade's native own-property ordering; nested default is not re-exported.
+ * the facade's native own-property ordering; nested default is not
+ * re-exported.
  *
  * @evidence contracts/common.md#principled-implementation Node createRequire resolves each edge from the physical source module using require conditions; the runtime supplies its existing source-rescue resolver on supported hook variants. Owned compiler bytes retain TypeScript elision and lowering. Static parsing discovers possible names, while the original loaded helper and facade own values and property semantics.
  * @evidence contracts/common.md#clear-and-simple-design One traversal serves both JavaScript and TypeScript facades. A call-scoped physical seen set prevents mixed-source cycles and duplicate reads without separate emitted/source resolution policies.
@@ -28,8 +29,10 @@ export function commonJsExportNames(
   source: string,
   filename: string,
   readSource: (file: string) => string | null,
-  resolve: (parent: string, specifier: string) => string = (parent, specifier) =>
-    createRequire(parent).resolve(specifier),
+  resolve: (parent: string, specifier: string) => string = (
+    parent,
+    specifier,
+  ) => createRequire(parent).resolve(specifier),
 ): string[] {
   const names = new Set<string>();
   const seen = new Set<string>();
@@ -42,7 +45,11 @@ export function commonJsExportNames(
       if (root || name !== "default") names.add(name);
     for (const specifier of parsed.reexports) {
       let target: string;
-      try { target = resolve(real, specifier); } catch { continue; }
+      try {
+        target = resolve(real, specifier);
+      } catch {
+        continue;
+      }
       if (!path.isAbsolute(target)) continue;
       if ([".json", ".node", ".mjs"].includes(path.extname(target))) continue;
       const physical = realPath(target);

package/src/launcher/internal/runtime/installRuntimeHooks.ts

@@ -34,14 +34,16 @@ import type { OwningModuleOptions } from "./OwningModuleOptions";
 import { PluginDescriptorInputObservation } from "./PluginDescriptorInputObservation";
 import type { ResolveResult } from "./ResolveResult";
 import { RuntimeEmitProvenance } from "./RuntimeEmitProvenance";
+import { RuntimeEntrySources } from "./RuntimeEntrySources";
 import { RuntimeFilesystem } from "./RuntimeFilesystem";
 import type { RuntimeHookOptions } from "./RuntimeHookOptions";
 import { RuntimeIsolatedEmit } from "./RuntimeIsolatedEmit";
 import { RuntimeLoaderCapabilities } from "./RuntimeLoaderCapabilities";
 import type { RuntimeManifest } from "./RuntimeManifest";
 import { RuntimeManifestRegistry } from "./RuntimeManifestRegistry";
-import { RuntimeProjectOwnership } from "./RuntimeProjectOwnership";
 import { RuntimeModuleFormat } from "./RuntimeModuleFormat";
+import { RuntimeProjectOwnership } from "./RuntimeProjectOwnership";
+import { advertiseTypeScriptExtensions } from "./advertiseTypeScriptExtensions";
 import { checkNodeRuntimeSupport } from "./checkNodeRuntimeSupport";
 import { commonJsExportNames } from "./commonJsExportNames";
 import { commonJsImportFacade } from "./commonJsImportFacade";
@@ -93,8 +95,10 @@ import { selectRuntimePluginPolicy } from "./selectRuntimePluginPolicy";
  * reach the API lacks on some releases is `require.resolve`, which is probed
  * before installation. Served CommonJS bodies receive an owned require function
  * whose resolve member applies the same source policy on those releases. Its
- * copied extension registry advertises the supported source extensions; foreign
- * resolver methods and global extension registries are never replaced.
+ * shared extension registry preserves live registrations. Installation also
+ * advertises missing CommonJS source extensions in the process registry because
+ * ecosystem tools inspect it before resolution; existing handlers remain intact
+ * and foreign resolver methods are never replaced.
  *
  * Direct descriptor evaluation records user preloads after hook installation.
  * Only the generated CommonJS output sibling takes Node's native resolve/load
@@ -103,7 +107,7 @@ import { selectRuntimePluginPolicy } from "./selectRuntimePluginPolicy";
  *
  * @evidence contracts/common.md#principled-implementation Resolution preserves successful Node decisions, rescues source spellings only after documented resolution fails, and serves only outputs whose ownership index names the exact source. CommonJS facades delegate native evaluation and project detected own named exports under the selected namespace capability; an owned module-local require supplies source resolution when native require.resolve bypasses public hooks.
  * @evidence contracts/common.md#clear-and-simple-design One synchronous hook owner coordinates source selection, emission ownership and descriptor observation; the entry, owning-project and orphan lanes remain explicit because they have distinct compilation premises. Private helpers carry those policies without a second foreign-resolver layer.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Public registerHooks handles resolution and loading; installation mutates neither Module._resolveFilename nor require.extensions. Source-extension recovery implements emitted-to-source spelling under the runtime contract, and module-local require adaptation addresses the probed public-hook difference without replacing Node methods.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Public registerHooks handles resolution and loading; installation adds missing public extension entries with Node's own JavaScript handler while preserving every existing handler and resolver method. Source-extension recovery implements emitted-to-source spelling under the runtime contract, and module-local require adaptation addresses the probed public-hook difference without replacing Node methods.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe the three serving lanes, compile gates, source identity, capability-based local adaptation and extension-registry ownership; helper comments state ownership and failure effects with descriptive prose separated from tags.
  * @evidence contracts/portability.md#os-neutral-implementation Node URL conversion, native filesystem paths and physical resolution preserve OS spelling boundaries. Actual public-hook probes select runtime capabilities, native emit uses executable arguments without shell interpolation, and unresolved filesystem observation refuses reusable descriptor proof.
  * @evidence contracts/performance.md#efficient-algorithms Source ownership indexes replace repeated whole-emit scans with indexed source/native-identity queries. Export discovery processes source/emit bytes, reexport edges, native resolution and Set/name unions under traversal-local seen sets; separate roots can repeat traversal. Config-chain validation reads discovered inputs. Compiler identity brackets and streams executable bytes on valid lookups, refusing failed observations. Native build/name-scan/orphan paths add compilation, path/metadata/IO cost; recursive graphs remain subject to stack limits.
@@ -133,6 +137,7 @@ export function installRuntimeHooks(options: RuntimeHookOptions = {}): void {
     process.setSourceMapsEnabled(true);
   }
   registerHooks({ load, resolve });
+  advertiseTypeScriptExtensions(require.extensions);
   PluginDescriptorInputObservation.begin(true);
   installed = true;
 }
@@ -390,7 +395,9 @@ function observePluginDescriptorResolutionCandidates(
         appendPluginDescriptorInputs(
           observation
             .commit(
-              selectedURL === undefined ? undefined : runtimeFilePath(selectedURL),
+              selectedURL === undefined
+                ? undefined
+                : runtimeFilePath(selectedURL),
             )
             .map((record) => `${JSON.stringify({ parent, ...record })}\n`),
         );
@@ -1003,13 +1010,17 @@ function servesCommonJsFromSource(url: string): boolean {
 }
 
 /** Scan both facade lanes from source paths using their actual require policy. */
-function runtimeCommonJsExportNames(filename: string, source: string): string[] {
+function runtimeCommonJsExportNames(
+  filename: string,
+  source: string,
+): string[] {
   return commonJsExportNames(
     source,
     filename,
-    (target) => isTypeScriptSource(target)
-      ? emitCommonJsForNameScan(target)
-      : readFileOrNull(target),
+    (target) =>
+      isTypeScriptSource(target)
+        ? emitCommonJsForNameScan(target)
+        : readFileOrNull(target),
     (parent, specifier) => {
       const native = createRequire(parent).resolve;
       return resolveCommonJsRequest(native, specifier, undefined, parent);
@@ -1227,20 +1238,20 @@ function resolveServedSource(
   prepareAsEntry: boolean = false,
 ): ServedSource {
   const real = realPath(filename);
-  let served = serveEntryEmit(real);
+  let served = serveInlinedEntryEmit(real, prepareAsEntry);
   if (served !== null) {
-    return withInlineSourceMap(served);
+    return served;
   }
   // Only the public preload can prepare a newly discovered root; direct ttsx
   // prepared its one entry before the child started.
   const prepareEntry = prepareAsEntry ? prepareRuntimeEntry : undefined;
   if (prepareEntry !== undefined) {
     RuntimeManifestRegistry.registerManifest(prepareEntry(real));
-    served = serveEntryEmit(real);
+    served = serveInlinedEntryEmit(real, true);
     if (served === null) {
       throw new Error(`ttsx: prepared entry emit not found for ${filename}`);
     }
-    return withInlineSourceMap(served);
+    return served;
   }
   const built = serveProjectEmit(real);
   if (built !== null) {
@@ -1723,10 +1734,36 @@ class RuntimeEmitOwnershipError extends Error {}
  * next lane and run something else.
  */
 function serveEntryEmit(real: string): ServedSource | null {
+  const owner = RuntimeManifestRegistry.findEntryEmit(real);
+  return owner === null ? null : entryEmitSource(owner, real);
+}
+
+/**
+ * {@link serveEntryEmit} with the emit's source map inlined, as a module load
+ * serves it. A checked entry build's emit is immutable for the run, so an entry
+ * load, which Node 22.15 repeats for the process entry, reads and source-maps
+ * each emitted file once (`RuntimeEntrySources`, samchon/ttsc#1749). Other
+ * modules are not remembered: Node keeps each loaded module, and holding every
+ * served text beside it would retain the whole program's emit.
+ */
+function serveInlinedEntryEmit(
+  real: string,
+  entry: boolean,
+): ServedSource | null {
   const owner = RuntimeManifestRegistry.findEntryEmit(real);
   if (owner === null) {
     return null;
   }
+  const prepare = () => withInlineSourceMap(entryEmitSource(owner, real));
+  return entry
+    ? RuntimeEntrySources.serve(owner.manifest, owner.emittedFile, prepare)
+    : prepare();
+}
+
+function entryEmitSource(
+  owner: NonNullable<ReturnType<typeof RuntimeManifestRegistry.findEntryEmit>>,
+  real: string,
+): ServedSource {
   return {
     emittedFile: owner.emittedFile,
     moduleOptions: owner.manifest.moduleOptions ?? {},
@@ -2339,16 +2376,25 @@ function owningTsconfig(real: string): string | null {
     recordPluginDescriptorProjectInputs,
   );
   if (nearest === null) return null;
-  // Config spelling and target identity do not prove that inherited options,
-  // reference roots or directory membership are unchanged. The resolver owns
-  // lookup-scoped reuse; a later import must ask it for a current answer.
+  // The project this selects is built once per process (`ensureProjectBuilt`),
+  // so the reference roots that select it are kept for the process as well;
+  // re-expanding them for every module cost a compiler run per referenced
+  // project (samchon/ttsc#1747). A file created after an expansion is still
+  // expanded for afresh.
   return resolveOwningProjectConfig({
+    expansions: ownerExpansions,
     file: real,
     onConfig: (config) => recordPluginDescriptorProjectInputs([config]),
     tsconfig: nearest,
   });
 }
 
+/** Reference roots `owningTsconfig` expanded in this process, by config. */
+const ownerExpansions = new Map<
+  string,
+  { files: readonly string[]; takenAt: number }
+>();
+
 function readFileOrNull(file: string | null): string | null {
   if (file === null) {
     return null;

package/src/launcher/internal/runtime/resolveRuntimeCleanTargets.ts

@@ -67,13 +67,22 @@ export function resolveRuntimeCleanTargets(cacheRoot: string): {
   const removable: string[] = [];
   for (const entry of entries) {
     const directory = path.join(physicalRuns, entry);
-    const observe = E2ETrace.runtimeCleanup(directory, runtime, "runtime-clean-selection");
+    const observe = E2ETrace.runtimeCleanup(
+      directory,
+      runtime,
+      "runtime-clean-selection",
+    );
     observe?.("selection-started");
     let ownership: ReturnType<typeof ProcessOwnedDirectory.ownership>;
     try {
-      ownership = ProcessOwnedDirectory.ownership(directory, false,
-        observe === undefined ? undefined : (observation) =>
-          observe("owner-observation", undefined, undefined, observation));
+      ownership = ProcessOwnedDirectory.ownership(
+        directory,
+        false,
+        observe === undefined
+          ? undefined
+          : (observation) =>
+              observe("owner-observation", undefined, undefined, observation),
+      );
     } catch (cause) {
       observe?.("selection-failed", undefined, cause);
       throw cause;
@@ -81,7 +90,10 @@ export function resolveRuntimeCleanTargets(cacheRoot: string): {
     observe?.("ownership", ownership);
     if (ownership !== "abandoned") kept.push(directory);
     else removable.push(directory);
-    observe?.(ownership === "abandoned" ? "removal-selected" : "retention-selected", ownership);
+    observe?.(
+      ownership === "abandoned" ? "removal-selected" : "retention-selected",
+      ownership,
+    );
   }
   return {
     kept,