@ttsc/unplugin 0.19.1 → 0.19.3

package/src/core/index.ts

@@ -4,8 +4,11 @@ import { createUnplugin } from "unplugin";
 import type { TtscUnpluginOptions } from "./options";
 import { resolveOptions } from "./options";
 import {
+  collectExternalInputHashes,
+  collectProjectInputHashes,
   createTtscTransformCache,
   isDeclarationFile,
+  isProjectWalkPath,
   stripQuery,
   transformTtsc,
 } from "./transform";
@@ -68,11 +71,24 @@ const unpluginFactory: UnpluginFactory<
         return undefined;
       }
       return transformTtsc(file, source, options, aliases, transformCache, {
-        // Register plugin-reported dependencies (the transform envelope's
-        // `dependencies` lists) so type-only inputs invalidate this module
-        // in watch mode; bundlers erase type-only imports from their own
-        // module graph and would otherwise serve stale generated code.
+        // Register the derived watch inputs (plugin-reported `dependencies`
+        // unioned with the host-owned reference graph) so type-only inputs
+        // invalidate this module in watch mode and persistent caches;
+        // bundlers erase type-only imports from their own module graph and
+        // would otherwise serve stale generated code.
         addWatchFile: (watched) => this.addWatchFile(watched),
+        // A module the plugin declared volatile depends on non-file inputs,
+        // which no file-dependency snapshot can represent; mark it
+        // uncacheable where the bundler exposes that control.
+        markVolatile: () => {
+          const native = this.getNativeBuildContext?.();
+          if (
+            native?.framework === "webpack" ||
+            native?.framework === "rspack"
+          ) {
+            native.loaderContext?.cacheable?.(false);
+          }
+        },
       });
     },
   };
@@ -86,7 +102,15 @@ export type {
   TtscUnpluginOptions,
 } from "./options";
 export type { TtscTransformHooks } from "./transform";
-export { createTtscTransformCache, resolveOptions, transformTtsc, unplugin };
+export {
+  collectExternalInputHashes,
+  collectProjectInputHashes,
+  createTtscTransformCache,
+  isProjectWalkPath,
+  resolveOptions,
+  transformTtsc,
+  unplugin,
+};
 
 export default unplugin;
 

package/src/core/transform.ts

@@ -51,6 +51,20 @@ export interface TtscTransformAlias {
  * miss on every module.
  */
 export interface TtscCachedProjectTransform {
+  /**
+   * SHA-256 hash of every input the compiler reported outside the project walk
+   * (keyed by absolute path), captured at the time of the transform.
+   *
+   * The project walk cannot see files outside the project root or under ignored
+   * directories (`node_modules` declarations, monorepo sibling sources,
+   * out-of-root tsconfig `extends` ancestry), yet the host-owned reference
+   * graph proves they are transform inputs. Long-lived hosts that never clear
+   * the cache between builds (Metro workers, the Turbopack loader, Bun) would
+   * otherwise replay a project transform computed against a stale out-of-walk
+   * input for the whole process lifetime; per-build hosts clear the cache on
+   * `buildStart` and never replay across edits.
+   */
+  externalInputHashes?: Record<string, string>;
   /**
    * SHA-256 hash of each project-relative input path at the time of the
    * transform.
@@ -60,6 +74,15 @@ export interface TtscCachedProjectTransform {
   projectRoot: string;
   /** Raw compiler output returned by {@link TtscCompiler.transform}. */
   result: ITtscCompilerTransformation;
+  /**
+   * Absolute path of the generated temp-dir tsconfig this compile ran against,
+   * when an alias/compiler-options overlay required one. The compiler reports
+   * it in the envelope's `graph.configs` chain, but it is disposed right after
+   * the compile, so registering it as a watch input would invalidate every
+   * bundler cache snapshot on the next build; watch derivation must skip
+   * exactly this path.
+   */
+  temporaryTsconfig?: string;
 }
 
 /**
@@ -85,12 +108,25 @@ export function createTtscTransformCache(): TtscTransformCache {
  */
 export interface TtscTransformHooks {
   /**
-   * Invoked once per absolute dependency path the plugin reported for the
-   * transformed file (`dependencies` in the transform envelope). Adapters
-   * forward this to the bundler's `addWatchFile` so type-only inputs
-   * participate in HMR invalidation.
+   * Invoked once per absolute watch-input path derived for the transformed file
+   * `F`: the plugin-reported `dependencies[F]` list unioned with the host-owned
+   * reference graph's contribution — the reachability closure of `graph.edges`
+   * from `F`, the `graph.globals` files, and the `graph.configs` chain — or,
+   * for a file the envelope declared `dependenciesComplete`, only
+   * `dependencies[F]` and the universal `graph.configs` chain. Adapters forward
+   * this to the bundler's `addWatchFile` so type-only inputs participate in
+   * watch-mode and persistent-cache invalidation. See {@link selectWatchInputs}
+   * for the exact derivation.
    */
   addWatchFile?: (file: string) => void;
+  /**
+   * Invoked when the plugin declared the transformed file volatile (the
+   * envelope's `volatile` list): its output depends on non-file inputs that no
+   * file-dependency snapshot can represent. Adapters should mark the module
+   * uncacheable where the bundler exposes that control (e.g. a webpack loader
+   * context's `cacheable(false)`).
+   */
+  markVolatile?: () => void;
 }
 
 /**
@@ -150,7 +186,17 @@ export async function transformTtsc(
     // A rejected in-flight generation must not stay cached: evict it (only if
     // it is still the current entry) so a later call re-runs the transform.
     const cached = await awaitOrEvict(cache, key, transformed);
-    if (matchesCachedSource(cached, file, source)) {
+    if (
+      // A file the plugin declared volatile must never be served from the
+      // cache: its output depends on non-file inputs, so the input-hash
+      // snapshot cannot prove freshness. Fall through to a fresh transform.
+      !isVolatileFile({
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+      }) &&
+      matchesCachedSource(cached, file, source)
+    ) {
       reportSuccessDiagnostics(cached.result);
       // A resolved `"exception"` / `"failure"` envelope makes this throw; that
       // is a failed generation too, so evict before surfacing it.
@@ -159,10 +205,11 @@ export async function transformTtsc(
         projectRoot: cached.projectRoot,
         result: cached.result,
       });
-      notifyFileDependencies(hooks, {
+      notifyWatchInputs(hooks, {
         file,
         projectRoot: cached.projectRoot,
         result: cached.result,
+        temporaryTsconfig: cached.temporaryTsconfig,
       });
       return createTransformResult(source, code);
     }
@@ -182,14 +229,21 @@ export async function transformTtsc(
     cache?.set(key, transformed);
   }
   const generation = transformed;
-  const { projectRoot, result } = await awaitOrEvict(cache, key, generation);
+  const { projectRoot, result, temporaryTsconfig } = await awaitOrEvict(
+    cache,
+    key,
+    generation,
+  );
   reportSuccessDiagnostics(result);
   const code = selectOrEvict(cache, key, generation, {
     file,
     projectRoot,
     result,
   });
-  notifyFileDependencies(hooks, { file, projectRoot, result });
+  notifyWatchInputs(hooks, { file, projectRoot, result, temporaryTsconfig });
+  if (isVolatileFile({ file, projectRoot, result })) {
+    hooks?.markVolatile?.();
+  }
   return createTransformResult(source, code);
 }
 
@@ -256,29 +310,232 @@ function evictGeneration(
 }
 
 /**
- * Forward the plugin-reported dependency list for `file` to the adapter's
- * `addWatchFile` hook.
+ * Forward every derived watch input for `file` to the adapter's `addWatchFile`
+ * hook: the plugin-reported `dependencies[file]` list unioned with the
+ * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
+ * `configs`).
  *
- * The transform envelope's `dependencies` keys mirror the `typescript` keys
- * (project-relative); values may be project-relative or absolute. Every path is
- * absolutized against the project root and deduplicated, and the file itself is
- * dropped; the bundler already watches the module it transforms.
+ * Envelope keys mirror the `typescript` keys (project-relative); values may be
+ * project-relative or absolute. Every path is absolutized against the project
+ * root and deduplicated; the file itself is dropped (the bundler already
+ * watches the module it transforms), and so is the disposed temp-dir tsconfig
+ * (see {@link TtscCachedProjectTransform.temporaryTsconfig}).
  */
-function notifyFileDependencies(
+function notifyWatchInputs(
   hooks: TtscTransformHooks | undefined,
   props: {
     file: string;
     projectRoot: string;
     result: ITtscCompilerTransformation;
+    temporaryTsconfig?: string;
   },
 ): void {
   const addWatchFile = hooks?.addWatchFile;
   if (addWatchFile === undefined) {
     return;
   }
-  for (const dependency of selectFileDependencies(props)) {
-    addWatchFile(dependency);
+  for (const input of selectWatchInputs(props)) {
+    addWatchFile(input);
+  }
+}
+
+/**
+ * Derive the absolute, deduplicated watch-input list for a single file.
+ *
+ * By default the derivation is a union: `dependencies[file] ∪ reach(edges,
+ * file) ∪ globals ∪ configs`. The plugin-reported list can only widen the
+ * host-owned language-semantic bound, never narrow it.
+ *
+ * An envelope that lists `file` in `dependenciesComplete` narrows it to
+ * `dependencies[file] ∪ configs`: the plugin declared its reported list the
+ * complete input set for that file, which transfers responsibility for the
+ * dropped `reach(edges, file) ∪ globals` bound to the plugin (see the protocol
+ * page's completeness contract). The config chain stays universal regardless,
+ * because compiler options reach generated code through the host rather than
+ * through any file a plugin could consult. A file the plugin also declared
+ * volatile keeps the baseline: the two declarations contradict, so the
+ * conservative one wins.
+ *
+ * Returns an empty list on exceptions.
+ */
+function selectWatchInputs(props: {
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+  temporaryTsconfig?: string;
+}): string[] {
+  const output: string[] = [];
+  const seen = new Set<string>();
+  const excluded = new Set(
+    props.temporaryTsconfig === undefined
+      ? [props.file]
+      : [props.file, path.resolve(props.temporaryTsconfig)],
+  );
+  for (const absolute of [
+    ...selectFileDependencies(props),
+    ...selectGraphInputs({
+      ...props,
+      complete: declaresCompleteDependencies(props) && !isVolatileFile(props),
+    }),
+  ]) {
+    if (excluded.has(absolute) || seen.has(absolute)) {
+      continue;
+    }
+    seen.add(absolute);
+    output.push(absolute);
   }
+  return output;
+}
+
+/**
+ * Flatten the host-owned reference graph for one file into absolute paths.
+ *
+ * The full contribution is the reachability closure of `edges` starting at the
+ * file, plus every global-scope file and the config chain. Flattening direct
+ * edges into a per-file list happens here — at the adapter boundary — because
+ * bundler `fileDependencies` snapshots are flat; the protocol itself carries
+ * only direct edges.
+ *
+ * `complete` drops the reach and globals halves, keeping only the universal
+ * config chain: the caller established that the plugin declared its own
+ * `dependencies[file]` list the complete replacement for them. Returns an empty
+ * list on exceptions or without a graph.
+ */
+function selectGraphInputs(props: {
+  complete: boolean;
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): string[] {
+  if (props.result.type === "exception") {
+    return [];
+  }
+  const graph = props.result.graph;
+  if (graph === undefined) {
+    return [];
+  }
+  const output: string[] = [];
+  if (!props.complete) {
+    output.push(...selectReachableEdges(props.projectRoot, props.file, graph));
+    output.push(...selectListedFiles(props.projectRoot, graph.globals));
+  }
+  output.push(...selectListedFiles(props.projectRoot, graph.configs));
+  return output;
+}
+
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it).
+ */
+function selectReachableEdges(
+  projectRoot: string,
+  file: string,
+  graph: ITtscCompilerTransformation.IReferenceGraph,
+): string[] {
+  const edges = new Map<string, string[]>();
+  for (const [source, targets] of Object.entries(graph.edges ?? {})) {
+    if (!Array.isArray(targets)) {
+      continue;
+    }
+    edges.set(
+      path.resolve(projectRoot, source),
+      targets
+        .filter(
+          (target): target is string =>
+            typeof target === "string" && target.length !== 0,
+        )
+        .map((target) => path.resolve(projectRoot, target)),
+    );
+  }
+  const output: string[] = [];
+  const visited = new Set<string>([file]);
+  const queue = [file];
+  while (queue.length !== 0) {
+    const current = queue.pop()!;
+    for (const target of edges.get(current) ?? []) {
+      if (visited.has(target)) {
+        continue;
+      }
+      visited.add(target);
+      queue.push(target);
+      output.push(target);
+    }
+  }
+  return output;
+}
+
+/**
+ * Absolutize one graph string list (`globals`, `configs`), skipping members a
+ * malformed envelope section may carry. Duplicates survive; the caller
+ * deduplicates the merged list.
+ */
+function selectListedFiles(projectRoot: string, listed: unknown): string[] {
+  if (!Array.isArray(listed)) {
+    return [];
+  }
+  const output: string[] = [];
+  for (const entry of listed) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      continue;
+    }
+    output.push(path.resolve(projectRoot, entry));
+  }
+  return output;
+}
+
+/**
+ * Report whether the plugin declared `file` volatile: its output depends on
+ * non-file inputs (environment, time, network), so neither the project
+ * transform cache nor a bundler's persistent cache may replay it.
+ */
+function isVolatileFile(props: {
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): boolean {
+  if (props.result.type === "exception") {
+    return false;
+  }
+  return declaresFile(props.result.volatile, props);
+}
+
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ */
+function declaresCompleteDependencies(props: {
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): boolean {
+  if (props.result.type === "exception") {
+    return false;
+  }
+  return declaresFile(props.result.dependenciesComplete, props);
+}
+
+/**
+ * Report whether one of the envelope's transformed-file lists (`volatile`,
+ * `dependenciesComplete`) names `file`. Members are keyed like `typescript`, so
+ * a project-relative and an absolute spelling of the same file both match; a
+ * malformed member is ignored rather than fatal.
+ */
+function declaresFile(
+  listed: unknown,
+  props: { file: string; projectRoot: string },
+): boolean {
+  if (!Array.isArray(listed)) {
+    return false;
+  }
+  return listed.some(
+    (entry) =>
+      typeof entry === "string" &&
+      entry.length !== 0 &&
+      path.resolve(props.projectRoot, entry) === props.file,
+  );
 }
 
 /**
@@ -384,9 +641,11 @@ export function createTransformResult(
  * in-memory source, then compares the snapshot against the one captured when
  * the result was produced. Any input under the project root changing (the
  * module itself or a sibling the plugin reads) invalidates the entry and forces
- * a re-transform. Out-of-walk inputs a plugin pulls in (`node_modules`
- * declarations, sibling-package sources) are not seen here; adapters invalidate
- * on those through the reported `dependencies` → `addWatchFile` → the bundler's
+ * a re-transform. Out-of-walk inputs the compiler reported (`node_modules`
+ * declarations, sibling-package sources, out-of-root config ancestry) are
+ * validated through {@link TtscCachedProjectTransform.externalInputHashes};
+ * adapters additionally register them as derived watch inputs (the host-owned
+ * `graph` union the reported `dependencies`) → `addWatchFile` → the bundler's
  * next `buildStart` cache clear.
  *
  * Both this snapshot and {@link collectInputHashes} draw their keys from the
@@ -405,7 +664,22 @@ function matchesCachedSource(
   const currentKey = toProjectKey(cached.projectRoot, file);
   const currentHashes = collectProjectInputHashes(cached.projectRoot);
   currentHashes[currentKey] = hashText(source);
-  return sameHashes(cached.inputHashes, currentHashes);
+  if (!sameHashes(cached.inputHashes, currentHashes)) {
+    return false;
+  }
+  // Re-hash the out-of-walk inputs the compiler reported for this generation
+  // over exactly the recorded key universe, so an edit to a `node_modules`
+  // declaration or a monorepo sibling source invalidates the entry even in a
+  // host that never clears the cache between builds. A new out-of-walk input
+  // cannot appear without some recorded input changing first: a new reference
+  // edge requires editing an in-walk source, and a new global or config file
+  // requires a tsconfig or package manifest change, both of which the project
+  // walk above already detects.
+  const externalHashes = cached.externalInputHashes ?? {};
+  return sameHashes(
+    externalHashes,
+    collectExternalInputHashes(Object.keys(externalHashes)),
+  );
 }
 
 /**
@@ -434,7 +708,13 @@ function collectInputHashes(props: {
   return hashes;
 }
 
-function collectProjectInputHashes(
+/**
+ * Hash every input file under `projectRoot` (the same walk universe
+ * {@link matchesCachedSource} validates against), keyed by project-relative
+ * slash path. Exported so hosts without a per-build boundary (`@ttsc/metro`)
+ * can fold the identical input universe into their own cache fingerprints.
+ */
+export function collectProjectInputHashes(
   projectRoot: string,
 ): Record<string, string> {
   const hashes: Record<string, string> = {};
@@ -484,6 +764,119 @@ function listProjectInputFiles(root: string): string[] {
   return out;
 }
 
+/**
+ * Report whether an absolute `file` belongs to the project walk universe of
+ * `root`: it lies under `root` and no segment of the relative path (including
+ * the basename) is an ignored directory name. The predicate mirrors
+ * {@link listProjectInputFiles} exactly, so "walk-visible" here means "hashed by
+ * {@link collectProjectInputHashes}". Anything else is an out-of-walk input that
+ * only the reference graph can prove relevant.
+ */
+export function isProjectWalkPath(root: string, file: string): boolean {
+  const relative = path.relative(path.resolve(root), path.resolve(file));
+  if (
+    relative.length === 0 ||
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    return false;
+  }
+  return relative
+    .split(path.sep)
+    .every((segment) => !isIgnoredProjectDirectory(segment));
+}
+
+/**
+ * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
+ * readable file, a stable `missing` marker otherwise. The marker is state, not
+ * an error — a recorded input disappearing (or reappearing) must change the
+ * comparison exactly like a content edit. Exported so `@ttsc/metro` can re-hash
+ * its recorded snapshot with identical semantics at cache-key time.
+ */
+export function collectExternalInputHashes(
+  paths: readonly string[],
+): Record<string, string> {
+  const hashes: Record<string, string> = {};
+  for (const file of paths) {
+    try {
+      hashes[file] = hashText(fs.readFileSync(file));
+    } catch {
+      hashes[file] = "missing";
+    }
+  }
+  return hashes;
+}
+
+/**
+ * Derive the absolute out-of-walk input set of a whole project transform: the
+ * union of every reference-graph member (edge keys and targets, globals, the
+ * config chain) and every plugin-reported dependency, minus everything the
+ * project walk already hashes and the disposed temp-dir tsconfig. These are the
+ * inputs {@link matchesCachedSource}'s walk cannot see.
+ *
+ * A `dependenciesComplete` declaration deliberately does not narrow this set,
+ * unlike the per-file watch derivation. This cache replays one whole envelope,
+ * so its validity condition is the union over every file the envelope carries
+ * rather than one file's inputs; a miss here costs a re-transform, never a
+ * stale output; and it is the layer that re-runs the plugin's analysis, which
+ * is how a widened declaration is ever learned. The narrowing that matters
+ * lands at the bundler boundary through {@link selectWatchInputs}, which is what
+ * feeds persistent caches and watch graphs.
+ */
+function selectExternalInputPaths(props: {
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+  temporaryTsconfig?: string;
+}): string[] {
+  if (props.result.type === "exception") {
+    return [];
+  }
+  const members: string[] = [];
+  const graph = props.result.graph;
+  if (graph !== undefined) {
+    for (const [source, targets] of Object.entries(graph.edges ?? {})) {
+      members.push(source);
+      if (Array.isArray(targets)) {
+        members.push(...targets);
+      }
+    }
+    for (const listed of [graph.globals, graph.configs]) {
+      if (Array.isArray(listed)) {
+        members.push(...listed);
+      }
+    }
+  }
+  for (const entries of Object.values(props.result.dependencies ?? {})) {
+    if (Array.isArray(entries)) {
+      members.push(...entries);
+    }
+  }
+  const excluded =
+    props.temporaryTsconfig === undefined
+      ? undefined
+      : path.resolve(props.temporaryTsconfig);
+  const output: string[] = [];
+  const seen = new Set<string>();
+  for (const member of members) {
+    if (typeof member !== "string" || member.length === 0) {
+      continue;
+    }
+    const absolute = path.resolve(props.projectRoot, member);
+    if (
+      absolute === excluded ||
+      seen.has(absolute) ||
+      isProjectWalkPath(props.projectRoot, absolute)
+    ) {
+      continue;
+    }
+    seen.add(absolute);
+    output.push(absolute);
+  }
+  output.sort();
+  return output;
+}
+
 function isIgnoredProjectDirectory(name: string): boolean {
   return (
     name === ".git" ||
@@ -544,7 +937,15 @@ async function transformProject(props: {
       projectRoot,
       tsconfig: configured.path,
     }).transform();
+    const temporaryTsconfig =
+      configured.path === props.tsconfig ? undefined : configured.path;
     return {
+      // Capture the out-of-walk input hashes while the generation is fresh so
+      // cache validation can re-check them; computed before dispose so the
+      // exclusion of the temp-dir tsconfig is the only reason it never keys.
+      externalInputHashes: collectExternalInputHashes(
+        selectExternalInputPaths({ projectRoot, result, temporaryTsconfig }),
+      ),
       inputHashes: collectInputHashes({
         currentFile: props.currentFile,
         currentSource: props.currentSource,
@@ -552,6 +953,10 @@ async function transformProject(props: {
       }),
       projectRoot,
       result,
+      // Remember the generated temp-dir tsconfig (disposed below) so watch
+      // derivation can drop it from the envelope's config chain; a registered
+      // but deleted file would invalidate every persistent-cache snapshot.
+      ...(temporaryTsconfig === undefined ? {} : { temporaryTsconfig }),
     };
   } finally {
     configured.dispose();

package/src/turbopack.ts

@@ -1,5 +1,6 @@
 import type { TtscUnpluginOptions } from "./core/options";
 import { resolveOptions } from "./core/options";
+import type { TtscTransformHooks } from "./core/transform";
 import {
   createTtscTransformCache,
   isDeclarationFile,
@@ -29,6 +30,13 @@ export interface TtscTurbopackLoaderContext {
    * build that predates the method) still loads.
    */
   addDependency?(file: string): void;
+  /**
+   * Toggle result cacheability. Part of the webpack loader context contract;
+   * called with `false` when the ttsc plugin declared the module volatile
+   * (output depends on non-file inputs), so the bundler never replays a cached
+   * result for it. Optional so a minimal stub context still loads.
+   */
+  cacheable?(flag: boolean): void;
 }
 
 /** Matches any path segment that is a `node_modules` directory (cross-platform). */
@@ -79,19 +87,29 @@ export default function turbopack(
     callback(undefined, source);
     return;
   }
-  // Forward plugin-reported dependencies into Turbopack's `fileDependencies`
-  // set so editing a type-only input a transform consulted re-runs this loader.
+  // Forward the derived watch inputs (plugin-reported dependencies plus the
+  // host-owned reference graph) into Turbopack's `fileDependencies` set so
+  // editing a type-only input a transform consulted re-runs this loader.
   // `addDependency` is bound so the webpack loader context stays `this` inside
   // it; the hook fires on cache hits too, which is required because the shared
-  // transform cache lives for the worker lifetime across requests.
+  // transform cache lives for the worker lifetime across requests. A module
+  // the plugin declared volatile is marked uncacheable through the same loader
+  // contract.
   const addDependency = this.addDependency?.bind(this);
+  const cacheable = this.cacheable?.bind(this);
+  const hooks: TtscTransformHooks = {
+    ...(addDependency === undefined ? {} : { addWatchFile: addDependency }),
+    ...(cacheable === undefined
+      ? {}
+      : { markVolatile: () => cacheable(false) }),
+  };
   transformTtsc(
     file,
     source,
     resolveOptions(this.getOptions?.() ?? {}),
     undefined,
     transformCache,
-    addDependency === undefined ? undefined : { addWatchFile: addDependency },
+    Object.keys(hooks).length === 0 ? undefined : hooks,
   ).then(
     (result) => callback(undefined, result?.code ?? source),
     (error) => callback(error),