ttsc 0.31.4 → 0.32.0

package/src/internal/pathIdentity/createFilesystemPathIdentityContext.ts

@@ -1,13 +1,10 @@
-import childProcess from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
-import { E2ETrace } from "../E2ETrace";
-import { OwnedSynchronousProcess } from "../OwnedSynchronousProcess";
-import { parseWindowsDirectoryCaseSensitivity } from "../parseWindowsDirectoryCaseSensitivity";
 import type { FilesystemPathIdentity } from "./FilesystemPathIdentity";
 import type { FilesystemPathIdentityContext } from "./FilesystemPathIdentityContext";
 import type { FilesystemPathIdentityOperations } from "./FilesystemPathIdentityOperations";
+import { createCaseSensitivityObservations } from "./createCaseSensitivityObservations";
 import { isFilesystemPathIdentityWithin } from "./isFilesystemPathIdentityWithin";
 import { resolveFilesystemPath } from "./resolveFilesystemPath";
 
@@ -47,19 +44,7 @@ export function createFilesystemPathIdentityContext(
   const readdir = operations.readdir ?? fs.readdirSync;
   const caseSensitive =
     operations.caseSensitive ??
-    ((directory: string) => {
-      try {
-        return filesystemDirectoryIsCaseSensitive(directory, platform, {
-          lstat,
-          readdir,
-          realpath,
-        });
-      } catch {
-        // A failed capability observation is unknown. This does not suppress
-        // strict physical identity errors in the separate realpath resolver.
-        return undefined;
-      }
-    });
+    createCaseSensitivityObservations({ lstat, platform, readdir, realpath });
 
   const resolve = (location: string): FilesystemPathIdentity => {
     const normalized = resolveFilesystemPath(location, platform);
@@ -262,150 +247,6 @@ function physicalRealpath(location: string): string {
   return fs.realpathSync.native?.(location) ?? fs.realpathSync(location);
 }
 
-function filesystemDirectoryIsCaseSensitive(
-  directory: string,
-  platform: NodeJS.Platform,
-  operations: {
-    lstat(location: string): fs.Stats | fs.BigIntStats;
-    readdir(directory: string): string[];
-    realpath(location: string): string;
-  },
-): boolean | undefined {
-  const pathApi = platform === "win32" ? path.win32 : path.posix;
-  let entries: string[];
-  try {
-    entries = operations.readdir(directory);
-  } catch {
-    return undefined;
-  }
-  const foldedNames = new Map<string, string>();
-  for (const name of entries) {
-    const folded = foldAsciiCase(name);
-    const previous = foldedNames.get(folded);
-    if (previous !== undefined && previous !== name) return true;
-    foldedNames.set(folded, name);
-  }
-  for (const name of entries) {
-    const alternate = alternateCase(name);
-    if (alternate === name) continue;
-    try {
-      operations.lstat(pathApi.join(directory, alternate));
-    } catch (error) {
-      if (isMissingFilesystemEntry(error)) {
-        // Enumeration is not an atomic snapshot. An absent alternate proves
-        // sensitivity only if the original spelling still names an entry.
-        try {
-          operations.lstat(pathApi.join(directory, name));
-          return true;
-        } catch (originalError) {
-          if (isMissingFilesystemEntry(originalError) === false)
-            throw originalError;
-        }
-        continue;
-      }
-      throw error;
-    }
-    try {
-      const actual = resolveFilesystemPath(
-        operations.realpath(pathApi.join(directory, name)),
-        platform,
-      );
-      const alias = resolveFilesystemPath(
-        operations.realpath(pathApi.join(directory, alternate)),
-        platform,
-      );
-      return actual !== alias;
-    } catch (error) {
-      if (isMissingFilesystemEntry(error) === false) throw error;
-    }
-  }
-  if (platform === "darwin") {
-    // APFS/HFS case semantics are volume-wide. An empty directory has no child
-    // name to probe, so ask the same read-only question of its existing name in
-    // the parent and walk upward until a name with ASCII case is available.
-    // This avoids a write probe while still distinguishing default APFS from a
-    // case-sensitive volume.
-    let current = resolveFilesystemPath(directory, platform);
-    while (true) {
-      const parent = pathApi.dirname(current);
-      if (parent === current) break;
-      // Names are interpreted by their parent; another mount is not evidence
-      // of the directory's own volume case policy.
-      if (operations.lstat(current).dev !== operations.lstat(parent).dev)
-        return undefined;
-      const name = pathApi.basename(current);
-      const alternate = alternateCase(name);
-      if (alternate !== name) {
-        try {
-          const actual = resolveFilesystemPath(
-            operations.realpath(current),
-            platform,
-          );
-          const alias = resolveFilesystemPath(
-            operations.realpath(pathApi.join(parent, alternate)),
-            platform,
-          );
-          return actual !== alias;
-        } catch (error) {
-          if (isMissingFilesystemEntry(error) === false) throw error;
-        }
-      }
-      current = parent;
-    }
-    return undefined;
-  }
-  if (platform !== "win32") return undefined;
-  // Node does not expose the Windows per-directory flag. Prefer fsutil's
-  // read-only answer; unavailable capability remains unknown.
-  const queried = queryWindowsDirectoryCaseSensitivity(directory);
-  if (queried !== undefined) return queried;
-  return undefined;
-}
-
-/**
- * Read the per-directory flag without depending on fsutil's display language.
- *
- * English output is cheap to recognize directly. Other Windows locales write
- * console-code-page bytes that Node cannot reliably decode, so their raw
- * message is interpreted against the volume-root query.
- */
-function queryWindowsDirectoryCaseSensitivity(
-  directory: string,
-): boolean | undefined {
-  const result = queryWindowsDirectoryCaseSensitivityBytes(directory);
-  if (result === undefined) return undefined;
-  const volumeRoot = path.win32.parse(directory).root;
-  const direct = parseWindowsDirectoryCaseSensitivity(
-    result,
-    undefined,
-    volumeRoot,
-  );
-  if (direct !== undefined) return direct;
-  const volume = queryWindowsDirectoryCaseSensitivityBytes(volumeRoot);
-  return parseWindowsDirectoryCaseSensitivity(result, volume, volumeRoot);
-}
-
-function queryWindowsDirectoryCaseSensitivityBytes(
-  directory: string,
-): Buffer | undefined {
-  const args = ["file", "queryCaseSensitiveInfo", directory];
-  const result = E2ETrace.synchronous(
-    "fsutil.exe",
-    args,
-    {},
-    "path-case-probe",
-    () =>
-      OwnedSynchronousProcess.launch("fsutil.exe", args, {
-        windowsHide: true,
-      }) ?? childProcess.spawnSync("fsutil.exe", args, { windowsHide: true }),
-  );
-  return result.error === undefined &&
-    result.status === 0 &&
-    Buffer.isBuffer(result.stdout)
-    ? result.stdout
-    : undefined;
-}
-
 function filesystemPathIdentityKey(
   location: string,
   platform: NodeJS.Platform,
@@ -415,14 +256,6 @@ function filesystemPathIdentityKey(
   return `${root.toLowerCase()}${location.slice(root.length)}`;
 }
 
-function alternateCase(value: string): string {
-  return value.replace(/[A-Za-z]/g, (character) =>
-    character === character.toLowerCase()
-      ? character.toUpperCase()
-      : character.toLowerCase(),
-  );
-}
-
 /** ASCII folding is the case equivalence observed by the read-only probes. */
 function foldAsciiCase(value: string): string {
   return value.replace(/[A-Z]/g, (character) => character.toLowerCase());

package/src/internal/probeLocalProcess.ts

@@ -12,7 +12,9 @@ import fs from "node:fs";
  * indefinitely, so its `/proc` status reports it absent too. A leader whose own
  * thread exited also reads as a zombie while its other threads run, so the
  * zombie must be the process's last thread. Its id cannot be reused while the
- * zombie holds it, so this never names a live process absent.
+ * zombie holds it, so this never names a live process absent. An absent answer
+ * carries its evidence: ESRCH, the /proc read's code when collection raced it,
+ * or the zombie's state, so a diagnostic reader can check which one held.
  *
  * @evidence contracts/common.md#principled-implementation ESRCH, or a Linux /proc status of zombie or dead with no other thread, proves the process exited; success with any other status is presence, and every other failure stays unknown.
  * @evidence contracts/common.md#clear-and-simple-design One probe gives the ttsx run, dependency-lock and plugin-lock owners the same exit decision.
@@ -26,6 +28,9 @@ import fs from "node:fs";
 export function probeLocalProcess(pid: number): {
   result: "present" | "absent" | "unknown";
   errorCode?: string;
+
+  /** The Linux /proc state that proved an exited process absent. */
+  state?: string;
 } {
   try {
     process.kill(pid, 0);
@@ -40,17 +45,17 @@ export function probeLocalProcess(pid: number): {
   } catch (error) {
     const code = (error as NodeJS.ErrnoException | null)?.code;
     // The process was collected between the probe and the read.
-    if (code === "ENOENT" || code === "ESRCH") return { result: "absent" };
+    if (code === "ENOENT" || code === "ESRCH")
+      return { result: "absent", errorCode: code };
     return { result: "unknown", errorCode: code };
   }
   // A leader whose own thread exited reads as a zombie while its other threads
   // still run; only a zombie that is the process's last thread has exited.
   const state = /^State:\s*(\S)/m.exec(status)?.[1];
   const threads = /^Threads:\s*(\d+)/m.exec(status)?.[1];
-  return {
-    result:
-      (state === "Z" || state === "X") && threads === "1"
-        ? "absent"
-        : "present",
-  };
+  // The state travels with an absent answer: signal zero succeeded, so it is the
+  // only evidence of the exit a diagnostic reader can check.
+  return (state === "Z" || state === "X") && threads === "1"
+    ? { result: "absent", state }
+    : { result: "present" };
 }

package/src/internal/projectInputPathIdentity.ts

@@ -16,6 +16,7 @@
 export * from "./pathIdentity/FilesystemPathIdentity";
 export * from "./pathIdentity/FilesystemPathIdentityOperations";
 export * from "./pathIdentity/FilesystemPathIdentityContext";
+export * from "./pathIdentity/createCaseSensitivityObservations";
 export * from "./pathIdentity/createFilesystemPathIdentityContext";
 export * from "./pathIdentity/isFilesystemPathIdentityWithin";
 export * from "./pathIdentity/resolveFilesystemPath";

package/src/launcher/internal/parseTtsxCLI.ts

@@ -14,10 +14,11 @@ import { assertTtsxNoWatch } from "./assertTtsxNoWatch";
  * Compiler flags before the first entry, repeated preloads and launcher-owned
  * settings are separated once through the shared flag schema. Terminal requests
  * are recognized only before the entry; unsupported watch/build requests fail
- * before a check, build or program is started. These decisions inspect the supplied
- * argv frame; this parser does not read response-file contents or certify their
- * eventual native effects. Preparation inspects response frames at the selected
- * project's actual compiler directory before requesting its build.
+ * before a check, build or program is started. These decisions inspect the
+ * supplied argv frame; this parser does not read response-file contents or
+ * certify their eventual native effects. Preparation inspects response frames
+ * at the selected project's actual compiler directory before requesting its
+ * build.
  *
  * @param argv Command tokens as received from the launcher.
  * @returns A terminal request or the launcher's typed option record.

package/src/launcher/internal/prepareExecution.ts

@@ -325,7 +325,10 @@ function createProjectContext(
     options.passthrough,
     options.binary,
   );
-  const privateEmitRootDir = resolveRuntimeSourceRoot(project, effectiveOptions);
+  const privateEmitRootDir = resolveRuntimeSourceRoot(
+    project,
+    effectiveOptions,
+  );
   // Resolved once: resolution costs a realpath (and, for a missing directory on
   // Windows, a case-sensitivity probe).
   const runtimeRootDir = createFilesystemPathIdentityContext({

package/src/launcher/internal/resolveSingleFileOutput.ts

@@ -14,15 +14,14 @@ import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscPa
  * then copies one transformed JavaScript file to this path, so project-mode
  * declaration, map, build-info, outFile, and broad outDir products are not
  * positional outputs. Explicit output mirrors cwd for contained sources and
- * uses the source basename for outside-layout or different-volume sources.
- * A supplied invocation project owns placement without
- * resolving the original locator again. Forwarded JSX uses the supplied native
- * argv frames and does not expand response-file requests here. CLI enum
- * normalization; an explicit reset selects the default suffix instead of
- * reviving the configured JSX. Placement-setting read failures use the
- * no-project fallback; that fallback does not certify a successful build or
- * valid configuration. Physical spelling is a current native observation, not a
- * pinned filesystem object.
+ * uses the source basename for outside-layout or different-volume sources. A
+ * supplied invocation project owns placement without resolving the original
+ * locator again. Forwarded JSX uses the supplied native argv frames and does
+ * not expand response-file requests here. CLI enum normalization; an explicit
+ * reset selects the default suffix instead of reviving the configured JSX.
+ * Placement-setting read failures use the no-project fallback; that fallback
+ * does not certify a successful build or valid configuration. Physical spelling
+ * is a current native observation, not a pinned filesystem object.
  *
  * @evidence contracts/common.md#principled-implementation CLI output wins over the selected project output; a contained cwd-relative source mirrors its layout while an outside-layout or cross-volume source uses its basename inside that explicit root. Supported extensions choose the emitted suffix, and physical root/file relation preserves configured project layout through links.
  * @evidence contracts/common.md#clear-and-simple-design Output placement delegates project settings and isolates containment, extension and forwarded-option readers; it does not materialize compiler side products.

package/src/launcher/internal/runTtsc.ts

@@ -578,11 +578,11 @@ function printCacheHelp(): void {
 
 /**
  * Adapt one normalized CLI request to its selected private producer and public
- * copy. The existing selection owns config and original argument anchoring;
- * the full request retains cache, reporting and watch callbacks. Only the
- * private helper writes the selected public file. Success presentation follows
- * that completed copy and describes public emission, without private products
- * or a fabricated transform-site count. Watch supplies quiet true itself.
+ * copy. The existing selection owns config and original argument anchoring; the
+ * full request retains cache, reporting and watch callbacks. Only the private
+ * helper writes the selected public file. Success presentation follows that
+ * completed copy and describes public emission, without private products or a
+ * fabricated transform-site count. Watch supplies quiet true itself.
  */
 function runSingleFile(
   options: ReturnType<typeof parseTtscBuildArgs> &

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/ProcessOwnedDirectory.ts

@@ -53,6 +53,9 @@ export namespace ProcessOwnedDirectory {
 
     /** Native code already caught by the operation, if it supplied one. */
     errorCode?: string;
+
+    /** The Linux /proc state that proved an exited owner absent. */
+    state?: string;
   }
 
   /**
@@ -192,12 +195,13 @@ export namespace ProcessOwnedDirectory {
           owner,
           observe === undefined
             ? undefined
-            : (result, errorCode) =>
+            : (result, errorCode, state) =>
                 report(observe, {
                   record: name,
                   owner,
                   result,
                   ...(errorCode === undefined ? {} : { errorCode }),
+                  ...(state === undefined ? {} : { state }),
                 }),
         )
       )

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/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);