@ttsc/metro 0.28.5 → 0.28.6

package/src/core/options.ts

@@ -53,6 +53,8 @@ export interface ResolvedTtscMetroOptions {
   include: string[];
   /** Resolved exclude patterns (never `undefined`). */
   exclude: string[];
+  /** Private run identity shared by `getCacheKey` and Metro workers. */
+  snapshotRunId?: string;
 }
 
 /**
@@ -71,8 +73,14 @@ export const ENV_KEY = "TTSC_METRO_OPTIONS";
  * Serialise user options for transport to the worker processes via
  * {@link ENV_KEY}.
  */
-export function serializeOptions(options: TtscMetroOptions): string {
-  return JSON.stringify(options ?? {});
+export function serializeOptions(
+  options: TtscMetroOptions,
+  snapshotRunId?: string,
+): string {
+  return JSON.stringify({
+    ...(options ?? {}),
+    ...(snapshotRunId === undefined ? {} : { __snapshotRunId: snapshotRunId }),
+  });
 }
 
 /**
@@ -98,10 +106,16 @@ export function resolveOptionsFromEnv(): ResolvedTtscMetroOptions {
         : undefined,
     include: toStringArray(parsed.include),
     exclude: toStringArray(parsed.exclude),
+    ...(typeof parsed.__snapshotRunId === "string" &&
+    parsed.__snapshotRunId.length !== 0
+      ? { snapshotRunId: parsed.__snapshotRunId }
+      : {}),
   };
 }
 
-function parse(raw: string | undefined): TtscMetroOptions {
+function parse(
+  raw: string | undefined,
+): TtscMetroOptions & { __snapshotRunId?: unknown } {
   if (raw === undefined || raw.length === 0) {
     return {};
   }
@@ -111,7 +125,7 @@ function parse(raw: string | undefined): TtscMetroOptions {
     // and booleans (all valid JSON) degrade to defaults rather than leaking a
     // wrong-shaped value downstream.
     return typeof value === "object" && value !== null && !Array.isArray(value)
-      ? (value as TtscMetroOptions)
+      ? (value as TtscMetroOptions & { __snapshotRunId?: unknown })
       : {};
   } catch {
     return {};

package/src/index.ts

@@ -79,16 +79,17 @@ export function withTtsc<T extends MetroConfigLike>(
   config: T,
   options: TtscMetroOptions = {},
 ): T {
-  process.env[ENV_KEY] = serializeOptions(
-    inheritConfiguredTransformer(config, options),
-  );
   // Prepare the reference-graph snapshot backing the transformer's cache-key
   // fingerprint (see `core/fingerprint.ts`). This runs in the single Metro
   // config process before any worker exists, so it is the race-free moment to
   // mint the snapshot epoch and compact the previous run's worker files.
-  prepareSnapshot(
+  const snapshotRunId = prepareSnapshot(
     typeof config.projectRoot === "string" ? config.projectRoot : undefined,
   );
+  process.env[ENV_KEY] = serializeOptions(
+    inheritConfiguredTransformer(config, options),
+    snapshotRunId,
+  );
   return {
     ...config,
     transformer: {

package/src/transformer.ts

@@ -17,6 +17,7 @@
  */
 import {
   createTtscTransformCache,
+  isTransformTarget,
   resolveOptions,
   transformTtsc,
 } from "@ttsc/unplugin/api";
@@ -36,14 +37,6 @@ import { resolveUpstreamTransformer } from "./core/upstream";
 
 const nodeRequire = createRequire(import.meta.url);
 
-/**
- * Matches the TypeScript source extensions the ttsc pass handles (`.ts`,
- * `.tsx`, `.cts`, `.mts`). JavaScript and declaration files are passed straight
- * through to the upstream transformer.
- */
-const TS_EXTENSION = /\.[cm]?tsx?$/;
-const DECLARATION = /\.d\.[cm]?ts$/;
-
 /**
  * Per-worker singletons. Metro loads this module once per worker process and
  * reuses it across every file that worker handles, so the resolved options, the
@@ -53,13 +46,19 @@ const DECLARATION = /\.d\.[cm]?ts$/;
 let resolved: ResolvedTtscMetroOptions | undefined;
 let unpluginOptions: ReturnType<typeof resolveOptions> | undefined;
 const cache = createTtscTransformCache();
-const snapshotRecorder = createSnapshotRecorder();
+let snapshotRecorder: ReturnType<typeof createSnapshotRecorder> | undefined;
 
 /** Lazily resolve the worker-side options (from {@link resolveOptionsFromEnv}). */
 function options(): ResolvedTtscMetroOptions {
   return (resolved ??= resolveOptionsFromEnv());
 }
 
+/** The recorder bound to the private run identity inherited by this worker. */
+function recorder(): ReturnType<typeof createSnapshotRecorder> {
+  const opts = options();
+  return (snapshotRecorder ??= createSnapshotRecorder(opts.snapshotRunId));
+}
+
 /**
  * Resolve Metro's per-file `filename` to an absolute path.
  *
@@ -121,15 +120,25 @@ export async function transform(params: {
         : undefined;
     const explicitProject =
       typeof opts.ttsc.project === "string" ? opts.ttsc.project : undefined;
+    const filename = resolveAbsoluteFilename(params.filename, params.options);
     const project = resolveProjectView({
       compilerOptions: opts.ttsc.compilerOptions,
       explicitProject,
+      filename,
       projectRoot,
     });
+    // Freeze the implicit selection made above into this call. Re-running
+    // discovery inside the transform after a config candidate changes would
+    // attach one project's recorder evidence to another project's compiler
+    // output.
+    const transformOptions = {
+      ...unpluginOptions,
+      project: project.tsconfig,
+    };
     const result = await transformTtsc(
-      resolveAbsoluteFilename(params.filename, params.options),
+      filename,
       params.src,
-      unpluginOptions,
+      transformOptions,
       undefined,
       cache,
       {
@@ -144,11 +153,15 @@ export async function transform(params: {
         // memo means stat-ing the whole `extends` chain, which is an answer
         // that cannot change between two inputs of one file
         // (samchon/ttsc#1316).
-        addWatchFile: (input) => snapshotRecorder.record({ input, project }),
+        addWatchFiles: (inputs) =>
+          recorder().recordMany({
+            inputs: [...project.discoveryInputs, ...inputs],
+            project,
+          }),
         // A volatile declaration means the output depends on non-file inputs
         // that no file fingerprint can represent; the snapshot marks it and
         // getCacheKey degrades to a per-run nonce (no cross-run reuse).
-        markVolatile: () => snapshotRecorder.recordVolatile({ project }),
+        markVolatile: () => recorder().recordVolatile({ project }),
       },
     );
     // A file the program does not contain comes back as `undefined` from the
@@ -179,16 +192,15 @@ export async function transform(params: {
  *   transformer's own key (forwarded Metro's args, e.g. `projectRoot`, so a
  *   `babel.config.js` change still busts the cache);
  * - The project fingerprint (see `core/fingerprint.ts`): every input file under
- *   the project walk (tsconfig, plugin configs, type-only siblings) plus the
- *   recorded out-of-walk reference-graph members from previous transforms
- *   (`node_modules` declarations, monorepo sibling sources, out-of-root config
- *   ancestry).
+ *   the routed project walks, every effective config source, the previous
+ *   transforms' derived inputs, and the epoch that isolates a worker state
+ *   differing from this run's exact main-process baseline.
  *
- * A change to any fingerprinted input re-keys every transformed file —
- * project-level granularity, forced by Metro's single static key — replacing
- * the former manual `--reset-cache` step. Resolving the upstream is
- * deliberately non-fatal here: a missing peer must not crash cache-key
- * computation. See the README "Caveats" and samchon/ttsc#721.
+ * A change to any fingerprinted input re-keys every transformed file at
+ * project-level granularity, forced by Metro's single static key, replacing the
+ * former manual `--reset-cache` step. Resolving the upstream is deliberately
+ * non-fatal here: a missing peer must not crash cache-key computation. See the
+ * README "Caveats" and samchon/ttsc#721.
  */
 export function getCacheKey(...args: unknown[]): string {
   const opts = options();
@@ -215,6 +227,7 @@ export function getCacheKey(...args: unknown[]): string {
       explicitProject:
         typeof opts.ttsc.project === "string" ? opts.ttsc.project : undefined,
       projectRoot: cacheKeyProjectRoot(args),
+      runId: opts.snapshotRunId,
     }),
   );
   return hash.digest("hex");
@@ -267,15 +280,15 @@ function upstreamCacheKey(
 
 /**
  * Decide whether a file should run through the ttsc pass. Only TypeScript
- * sources (`.ts`/`.tsx`/`.cts`/`.mts`, excluding `.d.ts`) qualify; `exclude`
- * substrings win over `include`, and an empty `include` means "all TypeScript".
- * Exported for unit testing.
+ * sources (`.ts`/`.tsx`/`.mts`/`.cts`, excluding every declaration form)
+ * qualify; `exclude` substrings win over `include`, and an empty `include`
+ * means "all TypeScript". Exported for unit testing.
  */
 export function shouldTransform(
   filename: string,
   opts: ResolvedTtscMetroOptions,
 ): boolean {
-  if (!TS_EXTENSION.test(filename) || DECLARATION.test(filename)) {
+  if (!isTransformTarget(filename)) {
     return false;
   }
   if (opts.exclude.some((pattern) => filename.includes(pattern))) {