ttsc 0.31.4 → 0.32.0

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

@@ -34,14 +34,15 @@ 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 { checkNodeRuntimeSupport } from "./checkNodeRuntimeSupport";
 import { commonJsExportNames } from "./commonJsExportNames";
 import { commonJsImportFacade } from "./commonJsImportFacade";
@@ -390,7 +391,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 +1006,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 +1234,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 +1730,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 +2372,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/isLocalProcessGone.ts

@@ -40,14 +40,16 @@ export function isLocalProcessGone(
   observe?: (
     result: "remote" | "present" | "absent" | "unknown",
     errorCode?: string,
+    state?: string,
   ) => void,
 ): boolean {
   const report = (
     result: "remote" | "present" | "absent" | "unknown",
     errorCode?: string,
+    state?: string,
   ): void => {
     try {
-      observe?.(result, errorCode);
+      observe?.(result, errorCode, state);
     } catch {
       // Diagnostics own no policy.
     }
@@ -56,7 +58,7 @@ export function isLocalProcessGone(
     report("remote");
     return false;
   }
-  const { result, errorCode } = probeLocalProcess(owner.pid);
-  report(result, errorCode);
+  const { result, errorCode, state } = probeLocalProcess(owner.pid);
+  report(result, errorCode, state);
   return result === "absent";
 }

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,

package/src/launcher/internal/watch/FseventsStreams.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import fs from "node:fs";
 import path from "node:path";
 
 import type { DirectoryWatcher } from "./DirectoryWatcher";
@@ -116,6 +117,7 @@ export class FseventsStreams {
     const displaced = [...(this.descendants.get(directory) ?? [])];
     const stream: Stream = {
       active: true,
+      openedAt: Date.now(),
       root: directory,
       stop: () => undefined,
       watches: new Map(),
@@ -209,6 +211,9 @@ type Watch = {
 
 type Stream = {
   active: boolean;
+
+  /** When the stream opened; nothing born before it was created in it. */
+  openedAt: number;
   root: string;
   stop: () => unknown;
   watches: Map<string, Set<Watch>>;
@@ -218,6 +223,8 @@ type Stream = {
 const GAP = 0x1 | 0x2 | 0x4 | 0x8 | 0x20 | 0x40 | 0x80;
 const MODIFIED = 0x400 | 0x1000 | 0x2000 | 0x4000 | 0x8000;
 const RENAMED = 0x100 | 0x200 | 0x800;
+const CREATED = 0x100;
+const MOVED = 0x200 | 0x800;
 
 function addWatch(stream: Stream, watch: Watch): void {
   const watches = stream.watches.get(watch.directory) ?? new Set<Watch>();
@@ -248,6 +255,21 @@ function deliver(stream: Stream, file: string, flags: number): void {
     deliverGap(stream);
     return;
   }
+  // FSEvents keeps ItemCreated on later writes to a path it saw created, so a
+  // plain edit of a file older than this stream arrived as a rename. An object
+  // born before the stream opened was not created in it; its other flags
+  // decide. A removal or a rename keeps the event structural.
+  if (
+    (flags & CREATED) !== 0 &&
+    (flags & MOVED) === 0 &&
+    (flags & MODIFIED) !== 0
+  ) {
+    try {
+      if (fs.lstatSync(target).birthtimeMs < stream.openedAt) flags &= ~CREATED;
+    } catch {
+      // A path gone by now keeps its creation flag.
+    }
+  }
   const event =
     (flags & MODIFIED) !== 0 && (flags & RENAMED) === 0 ? "change" : "rename";
   const deliveries: Array<{ name: string; watch: Watch }> = [];