@ttsc/unplugin 0.34.1 → 0.34.3

package/src/core/tsconfig/mergeMembershipPolicyOverlay.ts

@@ -3,6 +3,7 @@ import { JAVASCRIPT_INPUT_EXTENSIONS } from "./JAVASCRIPT_INPUT_EXTENSIONS";
 import { OUTPUT_DIRECTORY_OPTIONS } from "./OUTPUT_DIRECTORY_OPTIONS";
 import { flattenDirectoryExclusionOrigins } from "./flattenDirectoryExclusionOrigins";
 import { resolveConfigDirTemplatePath } from "./resolveConfigDirTemplatePath";
+import { resolveMembershipInputExtensions } from "./resolveMembershipInputExtensions";
 
 /**
  * Apply the caller's compiler-options overlay on top of a policy read from the
@@ -14,9 +15,10 @@ import { resolveConfigDirTemplatePath } from "./resolveConfigDirTemplatePath";
  * turns it off gets the narrower rule for the same reason.
  *
  * @evidence contracts/common.md#principled-implementation
- *   Explicit boolean overlays update extension admission and output path
- *   overlays update their own exclusion provenance. Null removes an output
- *   directory; missing legacy provenance preserves explicit exclusions.
+ *   Extension option provenance preserves explicit false and null clearing
+ *   while recomputing implicit JavaScript and JSON defaults. Mapper suffixes
+ *   remain independent. Output paths update their own exclusion provenance;
+ *   missing legacy provenance preserves authored extension/exclusion lists.
  *
  * @evidence contracts/common.md#clear-and-simple-design
  *   The operation clones extension and exclusion state rather than mutating
@@ -65,8 +67,27 @@ export function mergeMembershipPolicyOverlay(
       }
     }
   };
-  applyFlag("allowJs", JAVASCRIPT_INPUT_EXTENSIONS);
-  applyFlag("resolveJsonModule", [".json"]);
+  const extensionOptionOrigins =
+    policy.extensionOptionOrigins === undefined
+      ? undefined
+      : { ...policy.extensionOptionOrigins };
+  if (extensionOptionOrigins === undefined) {
+    applyFlag("allowJs", JAVASCRIPT_INPUT_EXTENSIONS);
+    applyFlag("resolveJsonModule", [".json"]);
+  } else {
+    for (const key of ["allowJs", "checkJs", "resolveJsonModule"] as const) {
+      if (!Object.hasOwn(compilerOptions, key)) continue;
+      const value = compilerOptions[key];
+      if (value === null) delete extensionOptionOrigins[key];
+      else if (typeof value === "boolean") extensionOptionOrigins[key] = value;
+    }
+    for (const key of ["module", "moduleResolution"] as const) {
+      if (!Object.hasOwn(compilerOptions, key)) continue;
+      const value = compilerOptions[key];
+      if (value === null) delete extensionOptionOrigins[key];
+      else if (typeof value === "string") extensionOptionOrigins[key] = value;
+    }
+  }
 
   const inheritedOrigins = policy.directoryExclusionOrigins;
   const directoryExclusionOrigins: {
@@ -98,7 +119,11 @@ export function mergeMembershipPolicyOverlay(
     excludedDirectories: flattenDirectoryExclusionOrigins(
       directoryExclusionOrigins,
     ),
-    inputExtensions: [...inputExtensions],
+    extensionOptionOrigins,
+    inputExtensions:
+      extensionOptionOrigins === undefined
+        ? [...inputExtensions]
+        : resolveMembershipInputExtensions(extensionOptionOrigins),
     sources: policy.sources,
     useCaseSensitiveFileNames: policy.useCaseSensitiveFileNames,
   };

package/src/core/tsconfig/readProjectMembershipPolicy.ts

@@ -1,8 +1,6 @@
 import path from "node:path";
 
-import { TYPESCRIPT_TRANSFORM_EXTENSIONS } from "../source/TYPESCRIPT_TRANSFORM_EXTENSIONS";
 import type { ITtscProjectMembershipPolicy } from "./ITtscProjectMembershipPolicy";
-import { JAVASCRIPT_INPUT_EXTENSIONS } from "./JAVASCRIPT_INPUT_EXTENSIONS";
 import { OUTPUT_DIRECTORY_OPTIONS } from "./OUTPUT_DIRECTORY_OPTIONS";
 import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { absolutizePathsTarget } from "./absolutizePathsTarget";
@@ -11,6 +9,7 @@ import { findDeclaredValue } from "./findDeclaredValue";
 import { flattenDirectoryExclusionOrigins } from "./flattenDirectoryExclusionOrigins";
 import { normalizeTypeScriptPathSeparators } from "./normalizeTypeScriptPathSeparators";
 import { resolveConfigDirTemplatePath } from "./resolveConfigDirTemplatePath";
+import { resolveMembershipInputExtensions } from "./resolveMembershipInputExtensions";
 import { resolveNativeRootPath } from "./resolveNativeRootPath";
 import { resolveRealPath } from "./resolveRealPath";
 
@@ -28,7 +27,8 @@ const DEFAULT_INCLUDE_SPEC = "**/*";
  * root matcher still applies extension, package and hidden-path admission; this
  * policy does not enumerate every dependency in the compiler program.
  *
- * `allowJs` and `resolveJsonModule` extend root-discovery suffixes, not the
+ * `allowJs` (implicitly enabled by `checkJs`), effective `resolveJsonModule`
+ * and literal content mapper extensions prime root-discovery suffixes, not the
  * complete set of imported or externally observed program inputs. `outDir`,
  * `declarationDir`, and plain `exclude` entries supply conservative directory
  * exclusions for that discovery walk. TypeScript supplies the two output
@@ -51,7 +51,7 @@ const DEFAULT_INCLUDE_SPEC = "**/*";
  *
  * @evidence contracts/common.md#clear-and-simple-design
  *   Shared declaration readers own inheritance; this operation assembles one
- *   policy and keeps exclusion provenance so overlays can change output defaults.
+ *   policy and keeps extension and exclusion provenance so overlays can recompute defaults. Own null options clear inherited declarations before default resolution.
  *
  * @evidence contracts/portability.md#os-neutral-implementation
  *   Node native paths anchor config-derived patterns; regular and native
@@ -117,25 +117,60 @@ export function readProjectMembershipPolicy(
             nativepath: resolveNativeRootPath(configDir),
           },
         };
-  const flag = (key: string): boolean =>
+  const option = (key: string): unknown =>
     findDeclaredValue(
       resolved,
       (parsed) => {
-        const value = (parsed as { compilerOptions?: Record<string, unknown> })
-          .compilerOptions?.[key];
-        return typeof value === "boolean" ? value : undefined;
+        const options = (
+          parsed as { compilerOptions?: Record<string, unknown> }
+        ).compilerOptions;
+        // Boxing null stops inheritance: upstream clears the inherited value.
+        return options !== null &&
+          typeof options === "object" &&
+          Object.hasOwn(options, key)
+          ? { value: options[key] }
+          : undefined;
       },
       new Set(),
       sources,
       configs,
-    )?.value === true;
-
-  const inputExtensions = [...TYPESCRIPT_TRANSFORM_EXTENSIONS];
-  if (flag("allowJs")) {
-    inputExtensions.push(...JAVASCRIPT_INPUT_EXTENSIONS);
-  }
-  if (flag("resolveJsonModule")) {
-    inputExtensions.push(".json");
+    )?.value.value;
+  const booleanOption = (key: string): boolean | undefined => {
+    const value = option(key);
+    return typeof value === "boolean" ? value : undefined;
+  };
+  const stringOption = (key: string): string | undefined => {
+    const value = option(key);
+    return typeof value === "string" ? value : undefined;
+  };
+  const extensions = new Set<string>();
+  const mappers =
+    findDeclaredValue(
+      resolved,
+      (parsed) => {
+        if (!Object.prototype.hasOwnProperty.call(parsed, "contentMappers"))
+          return undefined;
+        const value = (parsed as { contentMappers?: unknown }).contentMappers;
+        return Array.isArray(value) ? value : [];
+      },
+      new Set(),
+      sources,
+      configs,
+    )?.value ?? [];
+  for (const mapper of mappers) {
+    const declaredExtensions =
+      mapper !== null && typeof mapper === "object"
+        ? (mapper as { extensions?: unknown }).extensions
+        : undefined;
+    if (!Array.isArray(declaredExtensions)) continue;
+    for (const extension of declaredExtensions)
+      if (
+        typeof extension === "string" &&
+        extension.length > 1 &&
+        extension.startsWith(".") &&
+        !/[\\/]/.test(extension)
+      )
+        extensions.add(extension);
   }
 
   const directoryExclusionOrigins: {
@@ -221,13 +256,22 @@ export function readProjectMembershipPolicy(
       );
     }
   }
+  const extensionOptionOrigins = {
+    allowJs: booleanOption("allowJs"),
+    checkJs: booleanOption("checkJs"),
+    resolveJsonModule: booleanOption("resolveJsonModule"),
+    module: stringOption("module"),
+    moduleResolution: stringOption("moduleResolution"),
+    mapperExtensions: [...extensions],
+  };
   return {
     rootFileSpecs,
     directoryExclusionOrigins,
     excludedDirectories: flattenDirectoryExclusionOrigins(
       directoryExclusionOrigins,
     ),
-    inputExtensions,
+    extensionOptionOrigins,
+    inputExtensions: resolveMembershipInputExtensions(extensionOptionOrigins),
     sources: [...sources],
   };
 }

package/src/core/tsconfig/resolveMembershipInputExtensions.ts

@@ -0,0 +1,45 @@
+import { TYPESCRIPT_TRANSFORM_EXTENSIONS } from "../source/TYPESCRIPT_TRANSFORM_EXTENSIONS";
+import type { ITtscProjectMembershipPolicy } from "./ITtscProjectMembershipPolicy";
+import { JAVASCRIPT_INPUT_EXTENSIONS } from "./JAVASCRIPT_INPUT_EXTENSIONS";
+
+/**
+ * Prime suffix admission from explicit options and pinned TypeScript-Go
+ * defaults. Native membership reports still decide whether a primed walk was
+ * valid.
+ *
+ * @evidence contracts/common.md#principled-implementation Pinned 7.0 and 7.1 GetAllowJS, GetResolveJsonModule and GetModuleResolutionKind define these defaults: allowJs overrides checkJs; Node20/NodeNext enable implicit JSON; other modules use effective Bundler resolution unless Node16/18 or an explicit modern node resolution applies.
+ * @evidence contracts/common.md#clear-and-simple-design One pure resolver serves config inheritance and compiler-option overlays; declared mapper suffixes are unioned independently of built-in flags.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Constants describe upstream option semantics for supported targets, without consumer names or treating prediction as a native proof.
+ * @evidence contracts/common.md#meaningful-documentation Prose states the provisional role and native authority; the origins type documents missing options and mapper ownership.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Only compiler option labels and extension strings are interpreted; no filesystem path or process boundary is crossed.
+ * @evidence contracts/performance.md#efficient-algorithms Fixed option branches and one Set union cost O(mapper suffix count and text); output storage follows unique suffixes.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Resolves one supplied option value without coordinating requests or retaining a memo.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned array transfers to the caller; no handle or history is retained.
+ */
+export function resolveMembershipInputExtensions(
+  origins: NonNullable<ITtscProjectMembershipPolicy["extensionOptionOrigins"]>,
+): string[] {
+  const extensions = new Set(TYPESCRIPT_TRANSFORM_EXTENSIONS);
+  if (origins.allowJs ?? origins.checkJs)
+    for (const extension of JAVASCRIPT_INPUT_EXTENSIONS)
+      extensions.add(extension);
+  const module = origins.module?.toLowerCase();
+  const resolution = origins.moduleResolution?.toLowerCase();
+  const modernResolution =
+    resolution === "node16" ||
+    resolution === "nodenext" ||
+    resolution === "bundler";
+  const bundler = modernResolution
+    ? resolution === "bundler"
+    : module !== "node16" &&
+      module !== "node18" &&
+      module !== "node20" &&
+      module !== "nodenext";
+  if (
+    origins.resolveJsonModule ??
+    (module === "node20" || module === "nodenext" || bundler)
+  )
+    extensions.add(".json");
+  for (const extension of origins.mapperExtensions) extensions.add(extension);
+  return [...extensions];
+}

package/src/core/turbopack/turbopack.ts

@@ -10,6 +10,8 @@ import { TtscCompileFailureError } from "../transform/errors/TtscCompileFailureE
 import { readTtscTransformSession } from "../transform/session/readTtscTransformSession";
 import { shareTtscTransformCache } from "../transform/session/shareTtscTransformCache";
 import { transformTtsc } from "../transform/transformTtsc";
+import { captureCompilerArguments } from "../transform/tsconfig/captureCompilerArguments";
+import { resolveCompilerEnvironment } from "../transform/tsconfig/resolveCompilerEnvironment";
 import type { TtscProjectRegistration } from "../transform/watch/TtscProjectRegistration";
 import type { TtscTransformHooks } from "../transform/watch/TtscTransformHooks";
 import type { TtscTurbopackLoaderContext } from "./TtscTurbopackLoaderContext";
@@ -39,7 +41,9 @@ let bridge: HostWatchBridge | undefined;
  * The tool directories whose record inventory this worker has attempted for a
  * one-shot build, for a loader wired by hand, without `withTtsc`.
  */
-const refreshed = new Set<string>();
+const refreshed = new Map<string, string>();
+/** Last invocation admitted to the watching worker's record inventory. */
+let bridgeArgumentsIdentity: string | undefined;
 
 /**
  * Standalone webpack-loader entrypoint for Turbopack.
@@ -93,7 +97,7 @@ const refreshed = new Set<string>();
  *   Inclusion and shallow option/hook adaptation retain path/own-key text work.
  *   Shared transform validation pays current native identity, byte/list/graph
  *   proofs and compiler misses/map delivery; it is not one constant lookup.
- *   First inventory per tool root adds record parse/replay/IO, while watching
+ *   First inventory per tool root and changed invocation adds record parse/replay/IO, while watching
  *   registration adds qualified observer work and error modules serialize errors.
  * @evidence contracts/performance.md#reuse-equivalent-work
  *   A worker cache shares validated project generations across loader calls;
@@ -101,7 +105,7 @@ const refreshed = new Set<string>();
  *   boundary every hit qualifies current producer proofs before selecting output;
  *   native observer authority may avoid rereading proven unchanged populations.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   The worker owns its cache, bridge and refreshed-root set for its lifetime.
+ *   The worker owns its cache, bridge and refreshed-root identity map for its lifetime.
  *   Turbopack exposes no loader teardown hook, so native live resources rely on
  *   worker lifetime rather than this function's explicit join/close. Persistent
  *   session storage has its own pruning owner; no count/byte cap or descendant
@@ -149,6 +153,9 @@ export function turbopack(
   const projectRoot = this.rootContext ?? process.cwd();
   const toolDirectory = hostToolDirectory(projectRoot);
   const loaderOptions = bindings.readOptions();
+  const compilerArguments = captureCompilerArguments(
+    resolveCompilerEnvironment(loaderOptions.runExternalCode),
+  ).identity;
   // Turbopack gives a loader no build start, so the records are proven at the
   // process's first delivery. A watching worker's bridge takes every record as
   // it opens, proving them as it does, and observes the projects the worker
@@ -162,12 +169,25 @@ export function turbopack(
   if (watching && addDependency !== undefined) {
     if (bridge === undefined) {
       bridge = openHostWatchBridge(projectRoot);
-      refreshProjectRecordFiles(toolDirectory, bridge);
+    }
+    if (bridgeArgumentsIdentity !== compilerArguments) {
+      bridgeArgumentsIdentity = compilerArguments;
+      refreshProjectRecordFiles(
+        toolDirectory,
+        bridge,
+        undefined,
+        compilerArguments,
+      );
     }
     bridgeStartedAt = bridge.begin();
-  } else if (!refreshed.has(toolDirectory)) {
-    refreshed.add(toolDirectory);
-    refreshProjectRecordFiles(toolDirectory);
+  } else if (refreshed.get(toolDirectory) !== compilerArguments) {
+    refreshed.set(toolDirectory, compilerArguments);
+    refreshProjectRecordFiles(
+      toolDirectory,
+      undefined,
+      undefined,
+      compilerArguments,
+    );
   }
   const hooks: TtscTransformHooks = {
     exactPath: true,

package/src/core/unplugin.ts

@@ -36,6 +36,9 @@ import { resetTtscTransformCache } from "./transform/cache/resetTtscTransformCac
 import { sharedBuildTransformCache } from "./transform/cache/sharedBuildTransformCache";
 import { hostDeclaresPolling } from "./transform/tracker/hostDeclaresPolling";
 import { transformTtsc } from "./transform/transformTtsc";
+import { captureCompilerArguments } from "./transform/tsconfig/captureCompilerArguments";
+import { compilerEnvironmentIdentity } from "./transform/tsconfig/compilerEnvironmentIdentity";
+import { resolveCompilerEnvironment } from "./transform/tsconfig/resolveCompilerEnvironment";
 import { isHostWrapperQuery } from "./transform/utils/isHostWrapperQuery";
 import { stripQuery } from "./transform/utils/stripQuery";
 import type { TtscProjectRegistration } from "./transform/watch/TtscProjectRegistration";
@@ -96,6 +99,7 @@ const unpluginFactory: UnpluginFactory<
   // channel cannot observe, opened by the session's first watching delivery
   // and closed where the session ends (samchon/ttsc#1388).
   let bridge: HostWatchBridge | undefined;
+  let recordArgumentsIdentity: string | undefined;
   // The bridge's change sequence when the current pass opened. A pass proves
   // the generation once, at its first delivery, and serves every later module
   // of the pass from it, so a delivery may carry a state a change since the
@@ -176,13 +180,28 @@ const unpluginFactory: UnpluginFactory<
     (context.getNativeBuildContext?.() !== undefined ||
       context.meta?.rollupVersion === undefined);
   // The options a delivery to Rollup is compiled under, read again once the
-  // aliases Vite resolves change.
-  let deliveryOptions: { aliases: unknown; identity: string } | undefined;
+  // aliases Vite resolves or the effective compiler argument transport change.
+  let deliveryOptions:
+    | { aliases: unknown; environment: string; identity: string }
+    | undefined;
   const currentDeliveryOptions = (): string => {
-    if (deliveryOptions === undefined || deliveryOptions.aliases !== aliases)
+    const compilerEnvironment = resolveCompilerEnvironment(
+      options.runExternalCode,
+    );
+    const environment = compilerEnvironmentIdentity(compilerEnvironment);
+    if (
+      deliveryOptions === undefined ||
+      deliveryOptions.aliases !== aliases ||
+      deliveryOptions.environment !== environment
+    )
       deliveryOptions = {
         aliases,
-        identity: rollupDeliveryOptions(options, createAliasPaths(aliases)),
+        environment,
+        identity: rollupDeliveryOptions(
+          options,
+          createAliasPaths(aliases),
+          compilerEnvironment,
+        ),
       };
     return deliveryOptions.identity;
   };
@@ -494,7 +513,8 @@ const unpluginFactory: UnpluginFactory<
         // opens for its first pass and takes every record, so a project the
         // host restores whole from its cache, with no delivery in this
         // process, is observed from then on; a later pass of that session
-        // has the bridge observing already, and a one-shot host proves the
+        // has the bridge observing already; changed compiler arguments require
+        // a new inventory too. A one-shot host proves the
         // records at each start. A host whose cache the adapter answers module
         // by module, or that keeps none, has nothing for either to cover.
         const opening = bridge === undefined;
@@ -506,12 +526,17 @@ const unpluginFactory: UnpluginFactory<
           );
         }
         passStartedAt = bridge?.begin();
-        if (opening && restoresUnanswered(this)) {
+        if (restoresUnanswered(this)) {
+          const identity = captureCompilerArguments(
+            resolveCompilerEnvironment(options.runExternalCode),
+          ).identity;
+          const argumentsChanged = recordArgumentsIdentity !== identity;
+          recordArgumentsIdentity = identity;
           // Below the root, and in the fallback a host that cannot write there
           // keeps its records in (samchon/ttsc#1480).
-          for (const directory of recordDirectories()) {
-            refreshProjectRecordFiles(directory, bridge);
-          }
+          if (opening || argumentsChanged)
+            for (const directory of recordDirectories())
+              refreshProjectRecordFiles(directory, bridge, undefined, identity);
         }
       }
     },