@ttsc/metro 0.28.2 → 0.28.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/metro",
-  "version": "0.28.2",
+  "version": "0.28.4",
   "description": "Metro (React Native / Expo) adapter for ttsc plugins.",
   "main": "lib/index.js",
   "module": "lib/index.mjs",
@@ -35,7 +35,7 @@
     "src"
   ],
   "dependencies": {
-    "@ttsc/unplugin": "^0.28.2"
+    "@ttsc/unplugin": "^0.28.4"
   },
   "peerDependencies": {
     "@expo/metro-config": "*",
@@ -62,7 +62,7 @@
     "tinyglobby": "^0.2.16",
     "tslib": "^2.8.1",
     "typescript": "^7.0.2",
-    "ttsc": "0.28.2"
+    "ttsc": "0.28.4"
   },
   "repository": {
     "type": "git",

package/src/core/fingerprint.ts

@@ -48,6 +48,8 @@ import {
   collectExternalInputHashes,
   collectProjectInputHashes,
   isProjectWalkPath,
+  mergeMembershipPolicyOverlay,
+  readProjectMembershipPolicy,
 } from "@ttsc/unplugin/api";
 import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
@@ -131,10 +133,152 @@ export function fingerprintRoots(
   explicitProject: string | undefined,
 ): string[] {
   const tsconfig = resolveProjectTsconfig(base, explicitProject);
-  if (isProjectWalkPath(base, tsconfig)) {
-    return [base];
+  // Containment, not walk membership. The question here is whether the
+  // tsconfig's directory already sits inside the subtree the base walk covers,
+  // so that adding it would repeat the same walk. `isProjectWalkPath` answers a
+  // different question, whether the walk *hashes* that path, and once the walk
+  // stopped hashing files that cannot enter the program it began answering
+  // `false` for every `tsconfig.json`, which returned the base twice and hashed
+  // the whole project twice on every cache key (samchon/ttsc#1307).
+  const directory = path.dirname(path.resolve(tsconfig));
+  const relative = path.relative(path.resolve(base), directory);
+  const inside =
+    relative === "" ||
+    (relative !== ".." &&
+      !relative.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relative));
+  return inside ? [base] : [base, directory];
+}
+
+/**
+ * One project, and the membership policy that describes it.
+ *
+ * The recorder's question is whether the project walk already covers an input,
+ * so it needs both the walk's roots and the policy that walk used, and it is
+ * wrong exactly when those two describe different projects. Passing them
+ * separately made that mismatch expressible — the policy for one project
+ * alongside the root of another — and passing the policy alone made it
+ * expressible in a quieter way still, since a recorder that resolved its own
+ * could describe a different program than the walk hashed. Both halves travel
+ * together so neither can be supplied without the other (samchon/ttsc#1316).
+ */
+export interface TtscMetroProjectView {
+  /** The base directory both fingerprint sides agree on. */
+  readonly base: string;
+  /** The caller's explicit `project`, if any. */
+  readonly explicitProject: string | undefined;
+  /** The membership policy resolved for that project. */
+  readonly policy: ReturnType<typeof readProjectMembershipPolicy>;
+}
+
+/**
+ * Resolve one transform's project view, once, for every watch input it reports.
+ *
+ * Exported because the recorder is asked once per input while the answer is a
+ * property of the project, and validating the memo means stat-ing the whole
+ * `extends` chain (samchon/ttsc#1316).
+ */
+export function resolveProjectView(props: {
+  compilerOptions?: Record<string, unknown>;
+  explicitProject?: string;
+  projectRoot?: string;
+}): TtscMetroProjectView {
+  const base = resolveFingerprintBase(props.projectRoot);
+  return {
+    base,
+    explicitProject: props.explicitProject,
+    policy: membershipPolicy(
+      resolveProjectTsconfig(base, props.explicitProject),
+      props.compilerOptions,
+    ),
+  };
+}
+
+/**
+ * The membership policy of one project, memoized per resolved tsconfig and
+ * caller overlay.
+ *
+ * Every use of the walk pair has to ask the same policy, or the two halves
+ * disagree about the same project. The walk hashes what the configuration can
+ * admit, and `isProjectWalkPath` answers whether the walk covers a path, so a
+ * permissive answer here would claim coverage the walk does not provide and the
+ * input would be recorded nowhere at all (samchon/ttsc#1307).
+ */
+const MEMBERSHIP_POLICIES = new Map<
+  string,
+  {
+    policy: ReturnType<typeof readProjectMembershipPolicy>;
+    sources: readonly string[];
+    stamp: string;
   }
-  return [base, path.dirname(tsconfig)];
+>();
+
+function membershipPolicy(
+  tsconfig: string,
+  compilerOptions?: Record<string, unknown>,
+): ReturnType<typeof readProjectMembershipPolicy> {
+  // Keyed by the config's path and the caller's overlay, and never trusted on
+  // the key alone: a hit is served only while the config's own stamp still
+  // matches. A Metro worker outlives many runs, and this is consulted once per
+  // delivered file, so a memo that trusted its key would hold the policy a
+  // project had when the worker started. An edit adding `exclude` would then
+  // leave the worker judging a file in-walk while the next run's walk skipped
+  // it, which is precisely the both-sides-disagree hole this policy exists to
+  // close.
+  //
+  // The overlay belongs in the key rather than the stamp because it is part of
+  // the question, not part of any file: keyed by path alone the memo would hand
+  // a caller who passed `allowJs` the policy resolved for a caller who did not.
+  const key = [tsconfig, stableStringify(compilerOptions ?? {})].join(
+    String.fromCharCode(0),
+  );
+  const existing = MEMBERSHIP_POLICIES.get(key);
+  if (existing !== undefined && existing.stamp === stampOf(existing.sources)) {
+    return existing.policy;
+  }
+  // The caller's compiler-options overlay wins for the compile, so it has to
+  // win here too, exactly as it does in the adapter: a project given
+  // `allowJs: true` through `withTtsc` has a wider program than its tsconfig
+  // alone describes, and a narrower policy here would ask a different question
+  // about the same project (samchon/ttsc#1316).
+  const policy = mergeMembershipPolicyOverlay(
+    readProjectMembershipPolicy(tsconfig),
+    compilerOptions ?? {},
+    path.dirname(path.resolve(tsconfig)),
+  );
+  // Stamp the whole `extends` chain, not the leaf. Adding `exclude` to a shared
+  // `tsconfig.base.json` leaves the leaf's own mtime and size untouched while
+  // changing every answer the policy gives, so a leaf-only stamp would keep the
+  // worker on the pre-edit policy for its lifetime.
+  const sources =
+    policy.sources.length === 0 ? [tsconfig] : [...policy.sources];
+  MEMBERSHIP_POLICIES.set(key, {
+    policy,
+    sources,
+    stamp: stampOf(sources),
+  });
+  return policy;
+}
+
+/** A stamp over every config a policy was read from, in a stable order. */
+function stampOf(sources: readonly string[]): string {
+  return sources
+    .map((source) => {
+      try {
+        const stats = fs.statSync(source);
+        // A directory occupying a candidate path can never be the config, so it
+        // contributes its existence and not its modification time, which moves
+        // whenever any child is added or removed (samchon/ttsc#1316).
+        return stats.isDirectory()
+          ? `${source}:directory`
+          : `${source}:${stats.mtimeMs}:${stats.size}`;
+      } catch {
+        // Absent now. `readProjectMembershipPolicy` answers for that too, and
+        // the policy must be re-asked once the config appears.
+        return `${source}:absent`;
+      }
+    })
+    .join("|");
 }
 
 /**
@@ -173,14 +317,36 @@ function resolveProjectTsconfig(
  * cross-run cache reuse for this run instead of serving stale output.
  */
 export function computeProjectFingerprint(props: {
+  compilerOptions?: Record<string, unknown>;
   explicitProject?: string;
   projectRoot?: string;
 }): string {
   try {
     const base = resolveFingerprintBase(props.projectRoot);
     const hash = createHash("sha256");
+    // Judge the fingerprint's walk by the same configuration the compile
+    // does. Metro folds this into one static key, so an entry the program
+    // could never contain used to re-key every transformed file rather than
+    // costing one compile the way it does for a bundler (samchon/ttsc#1307).
+    //
+    // The caller's compiler-options overlay is part of that configuration, and
+    // has to reach the walk as well as the recorder. The two are the halves of
+    // one cache key and run in different processes, so they agree only by
+    // deriving from the same declared options: a walk resolved without the
+    // overlay while the recorder resolves with it leaves an overlay-admitted
+    // input in neither half, which is the both-sides-disagree hole in its
+    // quietest form (samchon/ttsc#1316).
+    const project = resolveProjectView({
+      compilerOptions: props.compilerOptions,
+      explicitProject: props.explicitProject,
+      projectRoot: props.projectRoot,
+    });
     for (const root of fingerprintRoots(base, props.explicitProject)) {
-      hash.update(stableStringify(collectProjectInputHashes(root)));
+      hash.update(
+        stableStringify(
+          collectProjectInputHashes(root, undefined, undefined, project.policy),
+        ),
+      );
     }
     const snapshot = readSnapshotState(base);
     if (snapshot === undefined || snapshot.volatile) {
@@ -386,14 +552,29 @@ export function readSnapshotState(base: string): SnapshotState | undefined {
  */
 export function createSnapshotRecorder(): {
   record: (props: {
-    explicitProject?: string;
     input: string;
-    projectRoot?: string;
-  }) => void;
-  recordVolatile: (props: {
-    explicitProject?: string;
-    projectRoot?: string;
+    /**
+     * The project this input belongs to, with the policy its walk uses,
+     * resolved once per transform through {@link resolveProjectView}.
+     *
+     * One value rather than a root and a policy side by side, because the
+     * recorder is wrong precisely when those two describe different projects.
+     * Deriving the policy here instead would be the same fault in a quieter
+     * form: a recorder that resolved its own could describe a different program
+     * than the walk hashed, which is what happened when the caller's
+     * compiler-options overlay reached one half and not the other, and the
+     * input was then covered by neither (samchon/ttsc#1316).
+     *
+     * Resolving it once per transform is also what makes it affordable.
+     * `record` runs once per watch input rather than once per file, and
+     * validating the memo means stat-ing the whole `extends` chain, measured at
+     * 12 microseconds per stat — a few thousand modules times fifteen inputs
+     * each cost over half a second per run for an answer that cannot change
+     * between two inputs of one file.
+     */
+    project: TtscMetroProjectView;
   }) => void;
+  recordVolatile: (props: { project: TtscMetroProjectView }) => void;
 } {
   const suffix = `${process.pid.toString(36)}-${randomBytes(6).toString("hex")}`;
   interface BaseState {
@@ -405,18 +586,15 @@ export function createSnapshotRecorder(): {
   }
   const states = new Map<string, BaseState>();
 
-  function stateFor(
-    projectRoot: string | undefined,
-    explicitProject: string | undefined,
-  ): BaseState {
-    const base = resolveFingerprintBase(projectRoot);
+  function stateFor(project: TtscMetroProjectView): BaseState {
+    const base = project.base;
     let state = states.get(base);
     if (state === undefined) {
       state = {
         dirty: false,
         files: new Set(),
         observed: false,
-        roots: fingerprintRoots(base, explicitProject),
+        roots: fingerprintRoots(base, project.explicitProject),
         volatile: false,
       };
       states.set(base, state);
@@ -459,15 +637,23 @@ export function createSnapshotRecorder(): {
 
   return {
     record(props) {
-      const base = resolveFingerprintBase(props.projectRoot);
-      const state = stateFor(props.projectRoot, props.explicitProject);
+      const base = props.project.base;
+      const state = stateFor(props.project);
       const input = path.resolve(props.input);
       const firstObservation = !state.observed;
       state.observed = true;
       if (
         state.files.has(input) ||
         (fs.existsSync(input) &&
-          state.roots.some((root) => isProjectWalkPath(root, input)))
+          state.roots.some((root) =>
+            isProjectWalkPath(
+              root,
+              input,
+              undefined,
+              undefined,
+              props.project.policy,
+            ),
+          ))
       ) {
         // Even when every input belongs to the project walk, the worker must
         // publish that it performed a clean transform. Otherwise an old main
@@ -483,8 +669,8 @@ export function createSnapshotRecorder(): {
       flush(base, state);
     },
     recordVolatile(props) {
-      const base = resolveFingerprintBase(props.projectRoot);
-      const state = stateFor(props.projectRoot, props.explicitProject);
+      const base = props.project.base;
+      const state = stateFor(props.project);
       if (state.volatile) {
         flush(base, state);
         return;

package/src/index.ts

@@ -27,7 +27,9 @@
  *   module.exports = withTtsc(getDefaultConfig(__dirname));
  *   ```
  */
-import { dirname, join } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { prepareSnapshot } from "./core/fingerprint";
@@ -64,12 +66,22 @@ interface MetroConfigLike {
  * With no `options`, the transformer auto-discovers `tsconfig.json` and runs
  * the plugins configured there: the standard ttsc model. Pass `options` only to
  * override the project path, plugin list, or include/exclude filters.
+ *
+ * A `babelTransformerPath` the config already carried is chained rather than
+ * replaced: it becomes the upstream this transformer delegates to, so wrapping
+ * a working config keeps whatever it configured. `react-native-svg-transformer`
+ * is installed by exactly that assignment, and replacing it silently sent every
+ * `.svg` to the auto-detected Expo default instead, with the build still
+ * succeeding (samchon/ttsc#1321). An explicit `upstreamTransformer` option
+ * still wins, since that is the caller saying it outright.
  */
 export function withTtsc<T extends MetroConfigLike>(
   config: T,
   options: TtscMetroOptions = {},
 ): T {
-  process.env[ENV_KEY] = serializeOptions(options);
+  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
@@ -86,6 +98,133 @@ export function withTtsc<T extends MetroConfigLike>(
   } as T;
 }
 
+/**
+ * Adopt the config's own `babelTransformerPath` as the upstream to delegate to.
+ *
+ * The value `withTtsc` overwrites is precisely the transformer that should run
+ * after the ttsc pass, so taking it as the default `upstreamTransformer` is
+ * what makes the wrapper additive in the one field it sets. Everything else in
+ * the config was already spread through untouched, which is what made the loss
+ * hard to see (samchon/ttsc#1321).
+ *
+ * An explicit option wins, and this package's own transformer is never adopted:
+ * a config wrapped twice would otherwise name this module as its own upstream
+ * and delegate into itself.
+ */
+function inheritConfiguredTransformer(
+  config: MetroConfigLike,
+  options: TtscMetroOptions,
+): TtscMetroOptions {
+  const declared = config.transformer?.babelTransformerPath;
+  if (
+    options.upstreamTransformer !== undefined ||
+    typeof declared !== "string" ||
+    declared.length === 0
+  ) {
+    return options;
+  }
+  // Resolve before judging. Ownership is a property of the module, not of the
+  // string, and every spelling has to become one absolute path before either
+  // question can be answered honestly.
+  const resolved = resolveFromProject(declared, config);
+  if (isOwnTransformer(resolved)) {
+    return options;
+  }
+  return { ...options, upstreamTransformer: resolved };
+}
+
+/**
+ * Resolve a declared `babelTransformerPath` the way Metro would: from the
+ * project.
+ *
+ * Metro resolves this value against the project, while the worker resolves
+ * `upstreamTransformer` with a `require` rooted in this package's own
+ * `lib/core`. Those are different places, so passing the caller's spelling
+ * through unchanged asks the worker to find the module somewhere it was never
+ * meant to be. Resolving here, once, in the config process that still knows the
+ * project root, removes the ambiguity for every spelling at once:
+ *
+ * - A relative `./metro-svg.cjs` becomes the file the caller meant, instead of
+ *   one looked for inside `@ttsc/metro` and not found;
+ * - A bare `react-native-svg-transformer` becomes its real location, which
+ *   matters under pnpm, where this package sits in a virtual store and walking
+ *   up from it never reaches the project's own `node_modules`;
+ * - An absolute path resolves to itself, unchanged;
+ * - And `require.resolve("@ttsc/metro/transformer")` — a caller who wired this
+ *   package by hand — becomes a path {@link isOwnTransformer} can recognise,
+ *   which no comparison against the bare specifier could.
+ *
+ * A specifier that cannot be resolved is handed on exactly as written. It may
+ * still resolve in the worker, and if it does not, `resolveUpstreamTransformer`
+ * names it in an error; inventing a path here would only move the failure
+ * somewhere less legible.
+ */
+function resolveFromProject(declared: string, config: MetroConfigLike): string {
+  const base =
+    typeof config.projectRoot === "string" && config.projectRoot.length !== 0
+      ? config.projectRoot
+      : process.cwd();
+  try {
+    return createRequire(join(resolve(base), "package.json")).resolve(declared);
+  } catch {
+    return declared;
+  }
+}
+
+/**
+ * Whether a `babelTransformerPath` already points at a `@ttsc/metro`
+ * transformer — this copy or any other.
+ *
+ * Adopting one would make this transformer its own upstream. That is not merely
+ * redundant: the worker options are process-global, so the adopted copy reads
+ * the same `TTSC_METRO_OPTIONS`, finds itself named there, and recurses until
+ * the stack ends. Comparing directory strings was not enough, because a second
+ * installed copy — a differently hoisted `node_modules`, a shared config
+ * package that already wrapped — lives in a different directory and passed the
+ * check.
+ *
+ * So the question asked is "is this module a `@ttsc/metro` transformer", not
+ * "is this string our path": the real path settles the same-copy case through
+ * symlinks and drive-letter spellings, and the owning `package.json` settles
+ * every other copy.
+ */
+function isOwnTransformer(declared: string): boolean {
+  const candidate = resolve(declared);
+  if (sameRealPath(candidate, transformerModulePath())) {
+    return true;
+  }
+  if (!/^transformer\.(?:js|mjs|cjs)$/i.test(basename(candidate))) {
+    return false;
+  }
+  try {
+    const manifest = join(dirname(dirname(candidate)), "package.json");
+    return JSON.parse(readFileSync(manifest, "utf8")).name === "@ttsc/metro";
+  } catch {
+    // No readable manifest beside it, so nothing identifies it as ours.
+    return false;
+  }
+}
+
+/**
+ * Whether two paths name the same file on disk.
+ *
+ * Resolved through `realpath` so a symlinked install and its target compare
+ * equal, and case-folded on Windows, where `D:\` and `d:\` and a differently
+ * cased base name all address one file.
+ */
+function sameRealPath(left: string, right: string): boolean {
+  const identity = (file: string): string => {
+    let resolved = resolve(file);
+    try {
+      resolved = realpathSync.native(resolved);
+    } catch {
+      // Not on disk: the resolved spelling is the best identity available.
+    }
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  };
+  return identity(left) === identity(right);
+}
+
 /**
  * Absolute path to the built transformer module Metro will `require`.
  *

package/src/transformer.ts

@@ -27,6 +27,7 @@ import path from "node:path";
 import {
   computeProjectFingerprint,
   createSnapshotRecorder,
+  resolveProjectView,
   stableStringify,
 } from "./core/fingerprint";
 import type { ResolvedTtscMetroOptions } from "./core/options";
@@ -112,7 +113,7 @@ export async function transform(params: {
   }
 
   let transformedSrc = params.src;
-  try {
+  {
     unpluginOptions ??= resolveOptions(opts.ttsc);
     const projectRoot =
       typeof params.options.projectRoot === "string"
@@ -120,6 +121,11 @@ export async function transform(params: {
         : undefined;
     const explicitProject =
       typeof opts.ttsc.project === "string" ? opts.ttsc.project : undefined;
+    const project = resolveProjectView({
+      compilerOptions: opts.ttsc.compilerOptions,
+      explicitProject,
+      projectRoot,
+    });
     const result = await transformTtsc(
       resolveAbsoluteFilename(params.filename, params.options),
       params.src,
@@ -133,25 +139,29 @@ export async function transform(params: {
         // that the next run's getCacheKey re-hashes instead. Fires on cache
         // hits too, so a worker that never recompiled still records the
         // inputs backing the outputs it serves.
-        addWatchFile: (input) =>
-          snapshotRecorder.record({ explicitProject, input, projectRoot }),
+        // The project view is resolved once for this file and handed to every
+        // one of its watch inputs. `record` runs per input, and validating the
+        // 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 }),
         // 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({ explicitProject, projectRoot }),
+        markVolatile: () => snapshotRecorder.recordVolatile({ project }),
       },
     );
+    // A file the program does not contain comes back as `undefined` from the
+    // shared transform, exactly as an unchanged one does, so it passes through
+    // here with no special case. That decision belongs to
+    // `@ttsc/unplugin`'s core and is shared with every bundler adapter; this
+    // transformer used to hold its own copy of it, recognising the case by
+    // searching the error text for "did not return output" while the adapters
+    // failed the build for the identical condition (samchon/ttsc#1308).
+    // Genuine compile and type failures still propagate so Metro surfaces them.
     if (result !== undefined && typeof result.code === "string") {
       transformedSrc = result.code;
     }
-  } catch (error) {
-    // A file that is not part of the tsconfig program is not a build error,
-    // pass it through untransformed. Genuine compile/type failures propagate so
-    // Metro surfaces them, matching the other ttsc bundler integrations.
-    if (!isFileOutsideProject(error)) {
-      throw error;
-    }
   }
 
   return upstream.transform({ ...params, src: transformedSrc });
@@ -198,6 +208,10 @@ export function getCacheKey(...args: unknown[]): string {
   }
   hash.update(
     computeProjectFingerprint({
+      // The same overlay `transform` hands the recorder. Both read these
+      // options from `options()`, so the walk and the recorder judge one
+      // project by one program (samchon/ttsc#1316).
+      compilerOptions: opts.ttsc.compilerOptions,
       explicitProject:
         typeof opts.ttsc.project === "string" ? opts.ttsc.project : undefined,
       projectRoot: cacheKeyProjectRoot(args),
@@ -276,16 +290,6 @@ export function shouldTransform(
   return true;
 }
 
-/**
- * `transformTtsc` throws `"ttsc transform did not return output for <file>"`
- * when the requested file is not part of the compiled program (e.g. excluded
- * from the tsconfig). That case is non-fatal: the file should pass through.
- */
-function isFileOutsideProject(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.includes("did not return output");
-}
-
 function packageVersion(): string {
   try {
     const pkg = nodeRequire("@ttsc/metro/package.json") as { version?: string };