@ttsc/unplugin 0.28.3 → 0.28.5

package/src/core/tsconfigPaths.ts

@@ -46,6 +46,189 @@ export function readEffectiveTsconfigPaths(
   return output;
 }
 
+/** Source extensions TypeScript always admits as program inputs. */
+const TYPESCRIPT_INPUT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+/** Extensions admitted only when `allowJs` widens the program. */
+const JAVASCRIPT_INPUT_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"];
+
+/**
+ * What the resolved configuration says can and cannot enter the program.
+ *
+ * The project walk exists to notice files entering and leaving the _program_,
+ * so both halves of that question belong to configuration rather than to a
+ * guess. Before this the walk answered both from one hardcoded list of
+ * directory names, which was wrong in both directions at once: a bundler
+ * writing to any directory the list did not name changed project membership
+ * with its own output, and a source directory whose name the list did name was
+ * dropped from the walk entirely (samchon/ttsc#1307).
+ */
+export interface ITtscProjectMembershipPolicy {
+  /** Absolute directories the resolved configuration keeps out of the program. */
+  excludedDirectories: readonly string[];
+  /** Lowercased extensions a file needs to be a possible program input. */
+  inputExtensions: readonly string[];
+  /**
+   * Every config file consulted to produce this policy, the leaf and its whole
+   * `extends` ancestry.
+   *
+   * A caller that memoizes a policy has to know when to stop trusting it, and
+   * the leaf alone cannot tell it: adding `exclude` to a shared
+   * `tsconfig.base.json` leaves the leaf untouched while changing every answer
+   * this policy gives.
+   */
+  sources: readonly string[];
+}
+
+/**
+ * The policy every project falls back to when no configuration is available.
+ *
+ * Deliberately the widest one: admitting a file that cannot enter the program
+ * costs a compile, while refusing one that can costs correctness, and only the
+ * second is a defect the user cannot see.
+ */
+export const PERMISSIVE_PROJECT_MEMBERSHIP_POLICY: ITtscProjectMembershipPolicy =
+  {
+    excludedDirectories: [],
+    inputExtensions: [
+      ...TYPESCRIPT_INPUT_EXTENSIONS,
+      ...JAVASCRIPT_INPUT_EXTENSIONS,
+      ".json",
+    ],
+    sources: [],
+  };
+
+/**
+ * Read the membership policy the resolved tsconfig implies, following its
+ * `extends` chain for every option the answer depends on.
+ *
+ * `allowJs` and `resolveJsonModule` decide which extensions can enter the
+ * program at all, so a `bundle.a1b2c3.js` emitted beside the sources is not a
+ * membership change for a project that admits no JavaScript. `outDir`,
+ * `declarationDir`, and the plain entries of `exclude` name the directories the
+ * program does not contain, which is where a bundler's own output lives in
+ * every project that configures one.
+ *
+ * A glob in `exclude` is skipped rather than approximated. Failing to exclude
+ * costs a walk; excluding the wrong tree hides real sources, and this function
+ * refuses to guess in the direction that loses correctness.
+ */
+export function readProjectMembershipPolicy(
+  tsconfig: string,
+): ITtscProjectMembershipPolicy {
+  const resolved = path.resolve(tsconfig);
+  // Every config the chain touches, so a caller memoizing this policy can tell
+  // when it has gone stale. `findDeclaredValue` walks `extends` for each option
+  // independently, and each walk records what it read.
+  const sources = new Set<string>();
+  const flag = (key: string): boolean =>
+    findDeclaredValue(
+      resolved,
+      (parsed) => {
+        const value = (parsed as { compilerOptions?: Record<string, unknown> })
+          .compilerOptions?.[key];
+        return typeof value === "boolean" ? value : undefined;
+      },
+      new Set(),
+      sources,
+    )?.value === true;
+
+  const inputExtensions = [...TYPESCRIPT_INPUT_EXTENSIONS];
+  if (flag("allowJs")) {
+    inputExtensions.push(...JAVASCRIPT_INPUT_EXTENSIONS);
+  }
+  if (flag("resolveJsonModule")) {
+    inputExtensions.push(".json");
+  }
+
+  const excludedDirectories: string[] = [];
+  for (const key of ["outDir", "declarationDir"]) {
+    const declared = findDeclaredValue(
+      resolved,
+      (parsed) => {
+        const value = (parsed as { compilerOptions?: Record<string, unknown> })
+          .compilerOptions?.[key];
+        return typeof value === "string" && value.length !== 0
+          ? value
+          : undefined;
+      },
+      new Set(),
+      sources,
+    );
+    if (declared !== null) {
+      excludedDirectories.push(path.resolve(declared.baseDir, declared.value));
+    }
+  }
+  const excluded = findDeclaredValue(
+    resolved,
+    (parsed) => {
+      const value = (parsed as { exclude?: unknown }).exclude;
+      return Array.isArray(value) ? value : undefined;
+    },
+    new Set(),
+    sources,
+  );
+  if (excluded !== null) {
+    for (const entry of excluded.value) {
+      if (typeof entry !== "string" || entry.length === 0) {
+        continue;
+      }
+      // `dist/**` names exactly one directory; `**/*.spec.ts` names a set this
+      // walk cannot evaluate without a matcher, so it is left in.
+      const plain = entry.endsWith("/**") ? entry.slice(0, -3) : entry;
+      if (plain.length === 0 || /[*?]/.test(plain)) {
+        continue;
+      }
+      excludedDirectories.push(path.resolve(excluded.baseDir, plain));
+    }
+  }
+  return { excludedDirectories, inputExtensions, sources: [...sources] };
+}
+
+/**
+ * Apply the caller's compiler-options overlay on top of a policy read from the
+ * project config.
+ *
+ * The overlay wins for the compile, so it wins here too. A caller that turns
+ * `allowJs` on gets a program that admits JavaScript, and a membership rule
+ * that still refused it would miss files entering that program; a caller that
+ * turns it off gets the narrower rule for the same reason.
+ */
+export function mergeMembershipPolicyOverlay(
+  policy: ITtscProjectMembershipPolicy,
+  compilerOptions: Record<string, unknown>,
+  baseDir: string,
+): ITtscProjectMembershipPolicy {
+  const inputExtensions = new Set(policy.inputExtensions);
+  const applyFlag = (key: string, extensions: readonly string[]): void => {
+    const value = compilerOptions[key];
+    if (typeof value !== "boolean") {
+      return;
+    }
+    for (const extension of extensions) {
+      if (value) {
+        inputExtensions.add(extension);
+      } else {
+        inputExtensions.delete(extension);
+      }
+    }
+  };
+  applyFlag("allowJs", JAVASCRIPT_INPUT_EXTENSIONS);
+  applyFlag("resolveJsonModule", [".json"]);
+
+  const excludedDirectories = [...policy.excludedDirectories];
+  for (const key of ["outDir", "declarationDir"]) {
+    const value = compilerOptions[key];
+    if (typeof value === "string" && value.length !== 0) {
+      excludedDirectories.push(path.resolve(baseDir, value));
+    }
+  }
+  return {
+    excludedDirectories,
+    inputExtensions: [...inputExtensions],
+    sources: policy.sources,
+  };
+}
+
 /**
  * Anchor a single `paths` target at `baseDir` unless it is already absolute,
  * normalizing to forward slashes. The `*` wildcard survives `path.resolve` as a
@@ -78,13 +261,57 @@ function findDeclaredPaths(
   tsconfig: string,
   seen: Set<string>,
 ): IDeclaredPaths | null {
+  const declared = findDeclaredValue(
+    tsconfig,
+    (parsed) => {
+      const own = (parsed as { compilerOptions?: { paths?: unknown } })
+        .compilerOptions?.paths;
+      return typeof own === "object" && own !== null && !Array.isArray(own)
+        ? (own as Record<string, unknown>)
+        : undefined;
+    },
+    seen,
+  );
+  return declared === null
+    ? null
+    : { baseDir: declared.baseDir, paths: declared.value };
+}
+
+/**
+ * Find the nearest declaration of one config value along the `extends` chain,
+ * with the directory of the config that declared it.
+ *
+ * TypeScript merges configs per key, so the effective value of a key is the
+ * whole value from the nearest config that declares one: the config itself
+ * first, then its `extends` entries in reverse priority order. The declaring
+ * directory travels with the value because a path-valued option (`outDir`,
+ * `exclude`) is anchored at the config that wrote it, not at the one that
+ * inherited it.
+ *
+ * Best-effort by design, like {@link readEffectiveTsconfigPaths}: a missing or
+ * unparsable config in the chain yields `null` here and a real config error
+ * from the compiler, which owns config diagnostics.
+ */
+function findDeclaredValue<T>(
+  tsconfig: string,
+  select: (parsed: object) => T | undefined,
+  seen: Set<string>,
+  /**
+   * Every config this walk reads, accumulated across walks. Kept apart from
+   * `seen`, which guards one walk against an `extends` cycle and must start
+   * empty each time: sharing one set would make the second option's walk treat
+   * the leaf as already visited and answer `null` for everything.
+   */
+  collect?: Set<string>,
+): { baseDir: string; value: T } | null {
   const canonical = resolveRealPath(tsconfig);
   if (seen.has(canonical)) {
     return null;
   }
   seen.add(canonical);
+  collect?.add(canonical);
 
-  let parsed: { extends?: unknown; compilerOptions?: { paths?: unknown } };
+  let parsed: { extends?: unknown };
   try {
     parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as typeof parsed;
   } catch {
@@ -94,20 +321,39 @@ function findDeclaredPaths(
     return null;
   }
 
-  const own = parsed.compilerOptions?.paths;
-  if (typeof own === "object" && own !== null && !Array.isArray(own)) {
-    return {
-      baseDir: path.dirname(canonical),
-      paths: own as Record<string, unknown>,
-    };
+  const own = select(parsed);
+  if (own !== undefined) {
+    return { baseDir: path.dirname(canonical), value: own };
   }
 
   for (const specifier of extendsSpecifiers(parsed.extends).reverse()) {
     const base = resolveExtendsConfig(canonical, specifier);
     if (base === null) {
+      // Record where a relative or absolute specifier *would* have resolved,
+      // even though nothing is there. A caller stamping this policy has to
+      // notice the config appearing later, and a base config can be absent for
+      // ordinary reasons: generated during install, or missing across a branch
+      // switch. Without this the stamp never moves and a long-lived worker
+      // keeps a policy the next run's walk already disagrees with. A bare
+      // specifier is skipped, since it has no single candidate path.
+      if (isRelativeSpecifier(specifier) || path.isAbsolute(specifier)) {
+        // Both spellings the resolver would have tried, since it falls back to
+        // `<specifier>.json`. Recording only the literal one leaves the stamp
+        // unmoved when `./tsconfig.base` later appears as `tsconfig.base.json`,
+        // which is the same staleness this recording exists to prevent.
+        const candidate = path.resolve(path.dirname(canonical), specifier);
+        collect?.add(candidate);
+        // Case-sensitive, because `resolveExistingExtendsPath` is: it appends
+        // `.json` unless the spelling already ends in exactly that, so a
+        // `./base.JSON` specifier really does resolve to `base.JSON.json` on a
+        // case-sensitive filesystem, and the stamp has to know that name.
+        if (!candidate.endsWith(".json")) {
+          collect?.add(`${candidate}.json`);
+        }
+      }
       continue;
     }
-    const declared = findDeclaredPaths(base, seen);
+    const declared = findDeclaredValue(base, select, seen, collect);
     if (declared !== null) {
       return declared;
     }

package/src/next.ts

@@ -1,11 +1,22 @@
 import type { TtscUnpluginOptions } from "./core/options";
 import webpack from "./webpack";
 
+/** The standalone loader entry Turbopack accepts through `turbopack.rules`. */
+const TURBOPACK_LOADER = "@ttsc/unplugin/turbopack";
+/**
+ * The globs the loader is wired for.
+ *
+ * The same two the manual wiring in the README uses. A wider glob would be
+ * harmless, since `isTransformTarget` declines everything else that reaches the
+ * loader, but it would also route files through a worker for nothing.
+ */
+const TURBOPACK_RULE_GLOBS = ["*.ts", "*.tsx"];
+
 /**
  * Minimal structural type for a Next.js configuration object.
  *
- * Only the `webpack` field is used by this adapter; all other Next.js options
- * are forwarded as-is through the spread operator.
+ * Only `webpack` and `turbopack` are used by this adapter; all other Next.js
+ * options are forwarded as-is through the spread operator.
  */
 export type NextLikeConfig = Record<string, unknown> & {
   /**
@@ -14,6 +25,11 @@ export type NextLikeConfig = Record<string, unknown> & {
    * webpack plugin.
    */
   webpack?: (config: WebpackLikeConfig, options: unknown) => WebpackLikeConfig;
+  /**
+   * Optional existing Turbopack configuration. Preserved whole; only the ttsc
+   * rules are merged into its `rules` map.
+   */
+  turbopack?: TurbopackLikeConfig;
 };
 
 /**
@@ -25,25 +41,40 @@ export type WebpackLikeConfig = Record<string, unknown> & {
   plugins?: unknown[];
 };
 
+/** Minimal structural type for Next.js's `turbopack` configuration block. */
+export type TurbopackLikeConfig = Record<string, unknown> & {
+  /** Per-glob loader rules. Other Turbopack settings are preserved untouched. */
+  rules?: Record<string, unknown>;
+};
+
 /**
- * Wrap a Next.js config object so that the ttsc webpack plugin is injected into
- * every webpack build Next.js performs.
+ * Wrap a Next.js config object so that ttsc runs under whichever bundler
+ * Next.js uses.
+ *
+ * The webpack plugin is injected through the `webpack` hook, and the Turbopack
+ * loader is wired through `turbopack.rules`, with the same options reaching
+ * both. Covering only webpack meant that a project on Turbopack, which is the
+ * default bundler in current Next majors, silently got no transform at all: the
+ * build succeeded and every plugin-driven construct in it, a typia
+ * `assert<T>()` above all, survived untransformed into a runtime failure
+ * (samchon/ttsc#1310).
  *
- * The adapter uses `unshift` to ensure the ttsc plugin runs before any other
- * plugins in the array (unplugin `enforce: "pre"` semantics). An existing
- * `nextConfig.webpack` hook is preserved and called after the plugin is
- * injected.
+ * Both halves are additive. An existing `webpack` hook is preserved and called
+ * after the plugin is injected, and an existing `turbopack` block keeps every
+ * setting and every rule it already had.
  *
  * @param nextConfig - The caller's existing Next.js config (spread into the
- *   returned object unchanged, except for `webpack`).
- * @param options - Ttsc plugin options forwarded to the webpack adapter.
+ *   returned object unchanged, except for `webpack` and `turbopack`).
+ * @param options - Ttsc plugin options forwarded to both bundlers.
  */
 export default function next(
   nextConfig: NextLikeConfig = {},
   options?: TtscUnpluginOptions,
 ): NextLikeConfig {
+  warnAboutSuppressedWebpackConfig(nextConfig);
   return {
     ...nextConfig,
+    turbopack: withTtscTurbopackRules(nextConfig.turbopack, options),
     webpack(config: WebpackLikeConfig, webpackOptions: unknown) {
       config.plugins = Array.isArray(config.plugins) ? config.plugins : [];
       // Prepend so ttsc runs before any user-added plugins.
@@ -55,3 +86,224 @@ export default function next(
     },
   };
 }
+
+/**
+ * Say what Next.js can no longer say once this wrapper defines `turbopack`.
+ *
+ * Next stops the build when a config carries a `webpack` hook and no
+ * `turbopack` block, because the webpack hook is then silently ignored. Read
+ * from Next 16.3.2's own `dist/lib/turbopack-warning.js`, it is
+ * `log.error(...)` followed by `process.exit(1)` — a refusal, not a warning —
+ * and it is gated on `process.env.TURBOPACK === "auto"`, which
+ * `dist/lib/bundler.js` sets only when no bundler flag was passed. Next's
+ * comment there gives the reason: an explicit `--turbopack` means the user
+ * chose it and is assumed to have configured it. So the check fires on a plain
+ * `next build` or `next dev`, which is how Next 16 is normally run.
+ *
+ * `hasTurboConfig` is read from the raw exported config, which is this
+ * wrapper's return value, and this wrapper always defines `turbopack`. The
+ * check therefore can never fire again for anyone who uses `withTtsc`, and a
+ * caller's own webpack customisation would be dropped on a Turbopack build with
+ * nothing said. Wiring ttsc for Turbopack is worth exactly one line, not the
+ * loss of the refusal Next already gave.
+ *
+ * Verifying that gate is what this docstring exists for: measured with an
+ * explicit `--turbopack`, the check is silent, and a reading that stopped there
+ * would conclude Next says nothing and delete a true statement.
+ *
+ * Only for a caller who wrote a `webpack` hook and no `turbopack` block. A
+ * caller who configured Turbopack has already made that decision, and a caller
+ * with neither has no webpack-only configuration to lose.
+ */
+function warnAboutSuppressedWebpackConfig(nextConfig: NextLikeConfig): void {
+  if (
+    typeof nextConfig.webpack !== "function" ||
+    nextConfig.turbopack !== undefined
+  ) {
+    return;
+  }
+  process.stderr.write(
+    "@ttsc/unplugin: withTtsc now configures Turbopack as well as webpack, so " +
+      "Next.js will no longer stop the build to tell you that your own " +
+      "`webpack` hook is ignored on a Turbopack build. Port it to `turbopack`, " +
+      "or run the bundler you configured with `next build --webpack` / " +
+      "`next dev --webpack`." +
+      String.fromCharCode(10),
+  );
+}
+
+/**
+ * Merge the ttsc loader rules into a caller's Turbopack configuration.
+ *
+ * Additive in every direction: unrelated Turbopack settings and unrelated rules
+ * are carried through untouched, and a glob the caller already configured keeps
+ * its own loaders with ttsc placed where the chain runs it first. A caller who
+ * already wired this loader by hand is left exactly as they are, so following
+ * the README's manual instructions and then adopting the wrapper cannot
+ * register it twice.
+ */
+function withTtscTurbopackRules(
+  existing: TurbopackLikeConfig | undefined,
+  options?: TtscUnpluginOptions,
+): TurbopackLikeConfig {
+  const rules: Record<string, unknown> = { ...(existing?.rules ?? {}) };
+  for (const glob of TURBOPACK_RULE_GLOBS) {
+    const rule = rules[glob];
+    const loaders = selectTurbopackLoaders(rule);
+    if (loaders.some(referencesTtscLoader)) {
+      continue;
+    }
+    // The caller may have written the same file set under a different glob.
+    // Adding ours beside theirs makes every matching module run the loader
+    // twice, and the second pass receives the first pass's output, so the
+    // guard has to cover the spellings a caller plausibly uses rather than
+    // only the two this wrapper writes (samchon/ttsc#1314).
+    if (coveredByAnotherRule(rules, glob)) {
+      continue;
+    }
+    const entry = { loader: TURBOPACK_LOADER, options: options ?? {} };
+    // Appended, not prepended. Turbopack runs a rule's loaders right to left,
+    // so the last entry is the one that sees the original source. ttsc
+    // transforms TypeScript into TypeScript, so it has to be that one, which
+    // is the same position `enforce: "pre"` gives it on the webpack half.
+    //
+    // Measured rather than inferred from webpack's `loader-runner`: two
+    // loaders on one rule, each marking the source, came back marked in the
+    // order that only the last-runs-first chain produces (samchon/ttsc#1319).
+    rules[glob] =
+      rule === undefined || loaders.length === 0
+        ? { loaders: [entry] }
+        : Array.isArray(rule)
+          ? { loaders: [...loaders, entry] }
+          : { ...(rule as object), loaders: [...loaders, entry] };
+  }
+  return { ...(existing ?? {}), rules };
+}
+
+/**
+ * Whether some other rule already routes this glob's files through the loader.
+ *
+ * Deciding glob equivalence in general means implementing Turbopack's matcher,
+ * which is not worth it here. What is recognised instead is the spellings a
+ * caller plausibly writes for "every file with this extension", since only a
+ * glob that means every file can make the wrapper's own rules redundant. That
+ * is narrower than every glob with those semantics, and narrow on purpose:
+ * anything unrecognised is left alone and the wrapper still adds its rules,
+ * while skipping on a scoped glob would leave every module outside that scope
+ * untransformed, which is samchon/ttsc#1310 again and the quieter of the two
+ * failures. {@link matchesExtension} owns the rule and names what it declines.
+ */
+function coveredByAnotherRule(
+  rules: Record<string, unknown>,
+  glob: string,
+): boolean {
+  const extension = glob.slice(glob.lastIndexOf(".") + 1);
+  return Object.entries(rules).some(([candidate, rule]) => {
+    if (candidate === glob) {
+      return false;
+    }
+    if (!selectTurbopackLoaders(rule).some(referencesTtscLoader)) {
+      return false;
+    }
+    return matchesExtension(candidate, extension);
+  });
+}
+
+/**
+ * Whether one glob names this extension across the whole project.
+ *
+ * Unscoped only. A rule carrying a path segment says nothing about the rest of
+ * the project, so treating it as covering everything would leave every module
+ * outside it with no ttsc rule at all. That is the silent failure
+ * samchon/ttsc#1310 is about, and it is strictly worse than the double
+ * registration this guard exists to prevent: a module no loader ever sees fails
+ * at runtime, while a module transformed twice costs time.
+ *
+ * How little a scoped rule covers is worth stating from measurement rather than
+ * from the obvious guess, because the guess is wrong. Against Next.js 16.3.2,
+ * `src/*.ts` and `src/**` + `/*.ts` match **nothing at all** — not even the
+ * `src/` subtree they name — while `./src/*.ts`, `**` + `/src/*.ts` and a bare
+ * `nested-probe.ts` all match a file at `src/`. Declining every one of them is
+ * therefore even safer than "it only covers its subtree" implies
+ * (samchon/ttsc#1319).
+ *
+ * The answer comes from {@link PROJECT_WIDE_GLOBS}, an exact set of measured
+ * spellings, and that document explains why it is a set rather than a rule.
+ */
+function matchesExtension(glob: string, extension: string): boolean {
+  return PROJECT_WIDE_GLOBS.get(glob.trim())?.includes(extension) === true;
+}
+
+/**
+ * The exact glob spellings a real Turbopack build has shown to name every file
+ * with an extension, and which extensions each one covers.
+ *
+ * An allowlist rather than a predicate, because recognising a glob is a claim
+ * about Turbopack's matcher and every claim here has to be one somebody
+ * measured. A rule inferred from glob semantics kept being wrong in the silent
+ * direction: `{src/,}*.ts` contains a bare `*.ts` alternative and so must cover
+ * the project by any set-theoretic reading, yet Turbopack matches nothing with
+ * it, and recognising it suppressed this wrapper's rules in favour of a rule
+ * that transforms no file at all — samchon/ttsc#1310 caused by the guard meant
+ * to prevent it (samchon/ttsc#1319).
+ *
+ * The deeper problem was that a predicate is open-ended: it answers for every
+ * spelling anyone might write, including ones no build has ever driven.
+ * `*.{ts}` and `{,**` + `/}*.ts` were both accepted on that reasoning while
+ * nothing had checked whether Turbopack expands a single-alternative group or a
+ * leading empty one. An exact set cannot overreach, so an unmeasured spelling
+ * is simply not recognised, the wrapper adds its own rules, and the failure —
+ * if any — is a second registration rather than a module that no loader ever
+ * sees.
+ *
+ * `experimental/test-unplugin` drives every entry through `next build
+ * --turbopack` and asserts a nested `.ts`, a root-level `.ts` and a nested
+ * `.tsx` all came out transformed, and
+ * `test_next_adapter_does_not_double_register_across_globs` asserts these keys
+ * and that list are the same set, so an entry cannot be added here without a
+ * build proving it.
+ */
+const PROJECT_WIDE_GLOBS: ReadonlyMap<string, readonly string[]> = new Map([
+  ["*.ts", ["ts"]],
+  ["**/*.ts", ["ts"]],
+  ["{**/,}*.ts", ["ts"]],
+  ["*.tsx", ["tsx"]],
+  ["**/*.tsx", ["tsx"]],
+  ["*.{ts,tsx}", ["ts", "tsx"]],
+  ["{*.ts,*.tsx}", ["ts", "tsx"]],
+  ["**/*.{ts,tsx}", ["ts", "tsx"]],
+  ["**/{*.ts,*.tsx}", ["ts", "tsx"]],
+  ["**/**/*.{ts,tsx}", ["ts", "tsx"]],
+]);
+
+/**
+ * Read the loader list out of one Turbopack rule.
+ *
+ * Turbopack accepts a bare array of loaders as well as the object form, and a
+ * loader is either a module name or a `{ loader, options }` pair, so this
+ * normalises only enough to answer "what is already here".
+ */
+function selectTurbopackLoaders(rule: unknown): unknown[] {
+  if (Array.isArray(rule)) {
+    return rule;
+  }
+  if (typeof rule === "object" && rule !== null) {
+    const loaders = (rule as { loaders?: unknown }).loaders;
+    if (Array.isArray(loaders)) {
+      return loaders;
+    }
+  }
+  return [];
+}
+
+/** Whether one Turbopack loader entry is already this package's loader. */
+function referencesTtscLoader(loader: unknown): boolean {
+  if (typeof loader === "string") {
+    return loader === TURBOPACK_LOADER;
+  }
+  return (
+    typeof loader === "object" &&
+    loader !== null &&
+    (loader as { loader?: unknown }).loader === TURBOPACK_LOADER
+  );
+}

package/src/turbopack.ts

@@ -1,9 +1,9 @@
+import { isTransformTarget } from "./core/index";
 import type { TtscUnpluginOptions } from "./core/options";
 import { resolveOptions } from "./core/options";
 import type { TtscTransformHooks } from "./core/transform";
 import {
   createTtscTransformCache,
-  isDeclarationFile,
   stripQuery,
   transformTtsc,
 } from "./core/transform";
@@ -39,9 +39,6 @@ export interface TtscTurbopackLoaderContext {
   cacheable?(flag: boolean): void;
 }
 
-/** Matches any path segment that is a `node_modules` directory (cross-platform). */
-const nodeModulesPattern = /(?:^|[/\\])node_modules(?:[/\\]|$)/;
-
 /**
  * Per-process transform cache. Turbopack runs loaders in a worker pool and
  * never signals build boundaries to a loader, so the cache lives for the
@@ -72,10 +69,11 @@ const transformCache = createTtscTransformCache();
  * ```
  *
  * Pass {@link TtscUnpluginOptions} through the rule's `options` object. The
- * loader returns the source unchanged for declaration files, `node_modules`
- * paths, and transforms that produce no change, mirroring the unplugin
- * adapters' `transformInclude` filter, since a broad rule glob routes
- * everything matching the extension through the loader.
+ * loader returns the source unchanged for anything {@link isTransformTarget}
+ * excludes — declaration files, `node_modules` paths, non-TypeScript sources,
+ * and virtual ids — and for transforms that produce no change. It applies that
+ * shared predicate itself rather than a local copy, because a broad rule glob
+ * routes everything matching the extension through the loader.
  */
 export default function turbopack(
   this: TtscTurbopackLoaderContext,
@@ -83,7 +81,13 @@ export default function turbopack(
 ): void {
   const callback = this.async();
   const file = stripQuery(this.resourcePath);
-  if (isDeclarationFile(file) || nodeModulesPattern.test(file)) {
+  // The shared predicate itself, not a copy of part of it. A rule glob wider
+  // than `*.ts`/`*.tsx` — the natural thing to write for a project with mixed
+  // sources, and the reason a loader needs a filter at all — used to route
+  // JavaScript and virtual ids into the whole-project transform that every
+  // other adapter excludes, where the program has no entry for them and the
+  // delivery fails (samchon/ttsc#1305).
+  if (!isTransformTarget(file)) {
     callback(undefined, source);
     return;
   }