@ttsc/unplugin 0.28.5 → 0.29.0

package/src/core/viteServe.ts

@@ -1,18 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
+import type { ITtscCompilerTransformation } from "ttsc";
 
-import { pathIdentityKey } from "./transform";
+import { pathIdentityKey, validateGraphInputObservation } from "./transform";
 
 /**
- * How often each registered missing watch input is stat-polled, in
+ * How often each registered Vite-unsafe input is predicate-polled, in
  * milliseconds.
  *
  * Polling is the only watch primitive that covers the whole class: the dev
  * server's chokidar watcher ignores every `node_modules` directory, which is
  * exactly where superseding resolution candidates usually live, and `fs.watch`
  * cannot observe a path whose parent directories do not exist yet. One `stat`
- * every half second per missing path is negligible against a dev server's
- * baseline.
+ * every half second per unavailable path is negligible against a dev server's
+ * baseline. Rich inputs replay only the predicates the compiler recorded.
  */
 const MISSING_INPUT_POLL_INTERVAL = 500;
 
@@ -55,24 +56,23 @@ export interface ViteDevServerLike {
 }
 
 /**
- * Filesystem watch for derived watch inputs that do not exist while a Vite dev
- * server is running.
+ * Filesystem watch for derived watch inputs that Vite cannot safely register as
+ * added imports while a development server is running.
  *
  * Vite serve treats every transform-context `addWatchFile()` registration as an
  * added import: `TransformPluginContext.addWatchFile` stores the path in
  * `_addedImports`, and `vite:import-analysis` resolves each entry like a real
- * import of the transformed module. A missing path — a superseding resolution
- * candidate or a plugin-reported dependency that is not generated yet — then
- * fails that resolve and turns the importer's first request into a 500, even
- * though the transform itself succeeded.
+ * import of the transformed module. A missing path or an existing directory
+ * that failed a compiler file predicate then fails that resolve and turns the
+ * importer's first request into a 500, even though the transform succeeded.
  *
  * This registry is the serve-only replacement for those registrations. Each
- * missing path is stat-polled; when it is created, every importer that
- * registered it is invalidated in the server's module graphs and one
- * full-reload is sent, so the next request retransforms the importer against
- * the new resolution winner. The project transform cache re-validates through
- * its external-input hashes (a recorded `missing` marker differs from a content
- * hash), so the retransform recompiles instead of replaying.
+ * path is polled until its exact compiler predicate observation changes; legacy
+ * envelopes retain their exists-or-file availability check. Its importers are
+ * then invalidated in the server's module graphs and one full-reload is sent,
+ * so the next request retransforms against the new resolution winner. The
+ * project transform cache re-validates the compiler observation, so the
+ * retransform recompiles instead of replaying.
  */
 export interface ViteServeMissingInputWatch {
   /** Adopt the dev server whose module graphs creation events invalidate. */
@@ -86,32 +86,57 @@ export interface ViteServeMissingInputWatch {
    * config's `command`, as the adapter does.
    */
   serving(): boolean;
-  /**
-   * Register one missing watch input derived for `importer`.
-   *
-   * `identity` is the filesystem identity the transform generation already
-   * resolved for `input`. Resolving it here instead costs a `realpath` and a
-   * case-sensitivity directory listing per input per delivery, because a
-   * per-call identity context memoizes nothing (samchon/ttsc#1246).
-   */
-  watch(input: string, importer: string, identity?: string): void;
+  /** Register one unsafe watch input and its exact recorded condition. */
+  watch(
+    input: string,
+    importer: string,
+    condition: ViteServeInputWatchCondition,
+  ): void;
 }
 
-/** Poll bookkeeping for one registered missing path. */
+/** A legacy availability condition or an exact compiler predicate proof. */
+export type ViteServeInputWatchCondition =
+  | "exists"
+  | "file"
+  | ITtscCompilerTransformation.IInputObservation;
+
+/** Poll bookkeeping for one registered unsafe path. */
 interface IMissingInputEntry {
+  condition: ViteServeInputWatchCondition;
   importers: Set<string>;
-  listener: (current: fs.Stats) => void;
   spelling: string;
 }
 
 /** Create an empty missing-input watch for one plugin instance. */
 export function createViteServeMissingInputWatch(): ViteServeMissingInputWatch {
   const entries = new Map<string, IMissingInputEntry>();
+  let poller: NodeJS.Timeout | undefined;
   let server: ViteDevServerLike | undefined;
 
-  const unwatch = (identity: string, entry: IMissingInputEntry): void => {
-    fs.unwatchFile(entry.spelling, entry.listener);
-    entries.delete(identity);
+  const stopPollingIfEmpty = (): void => {
+    if (entries.size !== 0 || poller === undefined) {
+      return;
+    }
+    clearInterval(poller);
+    poller = undefined;
+  };
+  const poll = (): void => {
+    const importers = new Set<string>();
+    for (const [identity, entry] of entries) {
+      if (!viteServeInputWatchConditionChanged(entry)) {
+        continue;
+      }
+      entries.delete(identity);
+      for (const importer of entry.importers) {
+        importers.add(importer);
+      }
+    }
+    stopPollingIfEmpty();
+    if (server === undefined || importers.size === 0) {
+      return;
+    }
+    invalidateImporters(server, importers);
+    sendFullReload(server);
   };
 
   return {
@@ -119,8 +144,10 @@ export function createViteServeMissingInputWatch(): ViteServeMissingInputWatch {
       server = next;
     },
     dispose() {
-      for (const [identity, entry] of entries) {
-        unwatch(identity, entry);
+      entries.clear();
+      if (poller !== undefined) {
+        clearInterval(poller);
+        poller = undefined;
       }
       // The server reference deliberately survives: `vite.restartServer`
       // configures the replacement server (attach) before it closes the old
@@ -132,60 +159,84 @@ export function createViteServeMissingInputWatch(): ViteServeMissingInputWatch {
     serving() {
       return server !== undefined;
     },
-    watch(input, importer, resolved) {
+    watch(input, importer, condition) {
       const spelling = path.resolve(input);
-      const identity = resolved ?? pathIdentityKey(spelling);
+      const identity = viteServeMissingInputWatchKey(spelling, condition);
       const existing = entries.get(identity);
       if (existing !== undefined) {
         existing.importers.add(path.resolve(importer));
         return;
       }
-      const entry: IMissingInputEntry = {
+      entries.set(identity, {
+        condition,
         importers: new Set([path.resolve(importer)]),
-        listener: (current) => {
-          // `fs.watchFile` reports a missing path as zeroed stats (and fires
-          // once with them right after registration); only a poll that
-          // observes a real file is a creation event.
-          if (current.mtimeMs === 0 && !fs.existsSync(entry.spelling)) {
-            return;
-          }
-          unwatch(identity, entry);
-          if (server === undefined) {
-            return;
-          }
-          invalidateImporters(server, entry.importers);
-          sendFullReload(server);
-        },
-        spelling,
-      };
-      entries.set(identity, entry);
-      const watcher = fs.watchFile(
         spelling,
-        { interval: MISSING_INPUT_POLL_INTERVAL },
-        entry.listener,
-      );
-      // A poller must never keep the dev-server process alive on its own.
-      watcher.unref?.();
-      // `fs.watchFile` snapshots the path's stats at registration and fires
-      // only on a subsequent change, so a file created between the adapter's
-      // existence check and this registration would count as "unchanged" and
-      // never fire. One deferred recheck closes that window; routing through
-      // the listener keeps a single finalization path.
-      const recheck = setTimeout(() => {
-        if (entries.get(identity) !== entry) {
-          return;
-        }
-        try {
-          entry.listener(fs.statSync(entry.spelling));
-        } catch {
-          // Still missing (or deleted again): the ordinary poll stays armed.
-        }
-      }, MISSING_INPUT_POLL_INTERVAL);
-      recheck.unref?.();
+      });
+      if (poller === undefined) {
+        poller = setInterval(poll, MISSING_INPUT_POLL_INTERVAL);
+        // A poller must never keep the dev-server process alive on its own.
+        poller.unref?.();
+      }
     },
   };
 }
 
+/** Key a private poll by predicate and exact lexical spelling. */
+export function viteServeMissingInputWatchKey(
+  input: string,
+  condition: ViteServeInputWatchCondition,
+): string {
+  // Missing aliases can share a physical parent now and later retarget or
+  // diverge. Neither predicate may let one lexical spelling answer for another.
+  const predicate =
+    typeof condition === "string"
+      ? condition
+      : `predicates:${JSON.stringify([
+          condition.accessibleEntries === undefined
+            ? null
+            : [
+                condition.accessibleEntries.directories,
+                condition.accessibleEntries.files,
+              ],
+          condition.directoryExists ?? null,
+          condition.fileExists ?? null,
+          condition.readFile === undefined
+            ? null
+            : condition.readFile.ok
+              ? [true, condition.readFile.hash]
+              : [false],
+          condition.realpath === undefined
+            ? null
+            : condition.realpath.ok
+              ? [true, condition.realpath.path]
+              : [false],
+          condition.stat ?? null,
+        ])}`;
+  return `${predicate}:${path.resolve(input)}`;
+}
+
+/** Whether one registered condition no longer describes its lexical path. */
+function viteServeInputWatchConditionChanged(
+  entry: IMissingInputEntry,
+): boolean {
+  if (typeof entry.condition !== "string") {
+    return (
+      validateGraphInputObservation(entry.spelling, entry.condition).length !==
+      0
+    );
+  }
+  try {
+    if (!fs.existsSync(entry.spelling)) {
+      return false;
+    }
+    return (
+      entry.condition === "exists" || !fs.statSync(entry.spelling).isDirectory()
+    );
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Invalidate every module-graph node of the registered importers so the next
  * request retransforms them. Importers keep their original absolute spelling so

package/src/next.ts

@@ -1,4 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import type { TtscUnpluginOptions } from "./core/options";
+import {
+  TYPESCRIPT_TRANSFORM_EXTENSIONS,
+  TYPESCRIPT_TURBOPACK_RULE_GLOBS,
+} from "./core/sourceExtensions";
 import webpack from "./webpack";
 
 /** The standalone loader entry Turbopack accepts through `turbopack.rules`. */
@@ -6,11 +14,11 @@ 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.
+ * The same exact set 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"];
+const TURBOPACK_RULE_GLOBS = TYPESCRIPT_TURBOPACK_RULE_GLOBS;
 
 /**
  * Minimal structural type for a Next.js configuration object.
@@ -147,35 +155,33 @@ function withTtscTurbopackRules(
   options?: TtscUnpluginOptions,
 ): TurbopackLikeConfig {
   const rules: Record<string, unknown> = { ...(existing?.rules ?? {}) };
+  // Package ownership is stable only for this configuration snapshot. A later
+  // call may observe an atomic install or a directory-link retarget at the same
+  // lexical loader path, so no verdict can escape this invocation.
+  const resolvedLoaderResults = new Map<string, boolean>();
   for (const glob of TURBOPACK_RULE_GLOBS) {
     const rule = rules[glob];
-    const loaders = selectTurbopackLoaders(rule);
-    if (loaders.some(referencesTtscLoader)) {
+    if (hasUnconditionalTtscLoader(rule, resolvedLoaderResults)) {
       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)) {
+    // only the four this wrapper writes (samchon/ttsc#1314).
+    if (coveredByAnotherRule(rules, glob, resolvedLoaderResults)) {
       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.
+    // Loader shorthand runs right to left, so ttsc is appended there to see
+    // the original source. Rule collections run matching items in order, so
+    // ttsc becomes an explicit first rule there for the same reason. That 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] };
+    rules[glob] = addUnconditionalTtscLoader(rule, entry);
   }
   return { ...(existing ?? {}), rules };
 }
@@ -196,13 +202,14 @@ function withTtscTurbopackRules(
 function coveredByAnotherRule(
   rules: Record<string, unknown>,
   glob: string,
+  resolvedLoaderResults: Map<string, boolean>,
 ): 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)) {
+    if (!hasUnconditionalTtscLoader(rule, resolvedLoaderResults)) {
       return false;
     }
     return matchesExtension(candidate, extension);
@@ -231,7 +238,7 @@ function coveredByAnotherRule(
  * 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;
+  return PROJECT_WIDE_GLOBS.get(glob)?.includes(extension) === true;
 }
 
 /**
@@ -256,54 +263,223 @@ function matchesExtension(glob: string, extension: string): boolean {
  * 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.
+ * `experimental/test-unplugin` reads this exported table from the installed
+ * package, drives every entry through one `next build --turbopack`, and asserts
+ * root, nested, and deep `.ts`, `.tsx`, `.mts`, and `.cts` sources match
+ * exactly the extension family recorded here. An entry therefore cannot be
+ * recognised without that same build measuring it.
+ */
+const TYPESCRIPT_EXTENSION_NAMES = TYPESCRIPT_TRANSFORM_EXTENSIONS.map(
+  (extension) => extension.slice(1),
+);
+const TYPESCRIPT_EXTENSION_GROUPS = extensionCombinations(
+  TYPESCRIPT_EXTENSION_NAMES,
+);
+
+/**
+ * Measured project-wide Turbopack globs and the source extensions each covers.
+ *
+ * Exported so the packed-package E2E can measure the exact production allowlist
+ * instead of maintaining a second list that can drift from 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"]],
+export const TURBOPACK_PROJECT_WIDE_GLOB_COVERAGE: ReadonlyArray<
+  readonly [string, readonly string[]]
+> = Object.freeze([
+  ...TYPESCRIPT_EXTENSION_NAMES.flatMap((extension) => {
+    const extensions = Object.freeze([extension]);
+    return [
+      Object.freeze([`*.${extension}`, extensions] as const),
+      Object.freeze([`**/*.${extension}`, extensions] as const),
+      Object.freeze([`{**/,}*.${extension}`, extensions] as const),
+    ];
+  }),
+  ...TYPESCRIPT_EXTENSION_GROUPS.flatMap(projectWideBraceGlobEntries),
 ]);
+const PROJECT_WIDE_GLOBS: ReadonlyMap<string, readonly string[]> = new Map(
+  TURBOPACK_PROJECT_WIDE_GLOB_COVERAGE,
+);
+
+/** Every source-extension subset of size two or more, in shared-table order. */
+function extensionCombinations(
+  extensions: readonly string[],
+): ReadonlyArray<readonly string[]> {
+  const output: Array<readonly string[]> = [];
+  const visit = (start: number, selected: string[]): void => {
+    for (let index = start; index < extensions.length; index += 1) {
+      const next = [...selected, extensions[index]!];
+      if (next.length >= 2) output.push(Object.freeze(next));
+      visit(index + 1, next);
+    }
+  };
+  visit(0, []);
+  return output;
+}
+
+/** Measured project-wide brace spellings for one extension family. */
+function projectWideBraceGlobEntries(
+  extensions: readonly string[],
+): ReadonlyArray<readonly [string, readonly string[]]> {
+  const suffixes = extensions.join(",");
+  const alternatives = extensions
+    .map((extension) => `*.${extension}`)
+    .join(",");
+  return [
+    Object.freeze([`*.{${suffixes}}`, extensions] as const),
+    Object.freeze([`{${alternatives}}`, extensions] as const),
+    Object.freeze([`**/*.{${suffixes}}`, extensions] as const),
+    Object.freeze([`**/{${alternatives}}`, extensions] as const),
+    Object.freeze([`**/**/*.{${suffixes}}`, extensions] as const),
+  ];
+}
 
 /**
- * Read the loader list out of one Turbopack rule.
+ * Add one unconditional loader without flattening Next's rule collection.
  *
- * 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".
+ * An array is either loader shorthand or a collection whose entries may be
+ * complete conditional rule objects, so it must remain an array. A collection
+ * executes every matching rule in order; its unconditional ttsc rule therefore
+ * comes first so it sees the original source before any caller rule. A
+ * conditioned object becomes that same two-item collection because putting ttsc
+ * inside the condition would leave the rest of the glob uncovered. An
+ * unconditioned object can keep its own shape while gaining the loader,
+ * including when it had no loaders.
  */
-function selectTurbopackLoaders(rule: unknown): unknown[] {
+function addUnconditionalTtscLoader(
+  rule: unknown,
+  entry: { loader: string; options: TtscUnpluginOptions },
+): unknown {
   if (Array.isArray(rule)) {
-    return rule;
+    return rule.every(isTurbopackLoaderItem)
+      ? [...rule, entry]
+      : [{ loaders: [entry] }, ...rule];
   }
   if (typeof rule === "object" && rule !== null) {
-    const loaders = (rule as { loaders?: unknown }).loaders;
-    if (Array.isArray(loaders)) {
-      return loaders;
+    if ((rule as { condition?: unknown }).condition !== undefined) {
+      return [{ loaders: [entry] }, rule];
     }
+    return {
+      ...rule,
+      loaders: [...selectTurbopackConfigLoaders(rule), entry],
+    };
   }
-  return [];
+  return { loaders: [entry] };
 }
 
-/** Whether one Turbopack loader entry is already this package's loader. */
-function referencesTtscLoader(loader: unknown): boolean {
-  if (typeof loader === "string") {
-    return loader === TURBOPACK_LOADER;
+/** Read the direct loader list from one Turbopack rule configuration item. */
+function selectTurbopackConfigLoaders(rule: unknown): unknown[] {
+  if (typeof rule !== "object" || rule === null || Array.isArray(rule)) {
+    return [];
+  }
+  const loaders = (rule as { loaders?: unknown }).loaders;
+  return Array.isArray(loaders) ? loaders : [];
+}
+
+/** Whether a rule collection provides this loader without a condition. */
+function hasUnconditionalTtscLoader(
+  rule: unknown,
+  resolvedLoaderResults: Map<string, boolean>,
+): boolean {
+  if (Array.isArray(rule)) {
+    return rule.some((item) => {
+      if (isTurbopackLoaderItem(item)) {
+        return referencesTtscLoader(item, resolvedLoaderResults);
+      }
+      return (
+        typeof item === "object" &&
+        item !== null &&
+        (item as { condition?: unknown }).condition === undefined &&
+        selectTurbopackConfigLoaders(item).some((loader) =>
+          referencesTtscLoader(loader, resolvedLoaderResults),
+        )
+      );
+    });
   }
   return (
-    typeof loader === "object" &&
-    loader !== null &&
-    (loader as { loader?: unknown }).loader === TURBOPACK_LOADER
+    typeof rule === "object" &&
+    rule !== null &&
+    (rule as { condition?: unknown }).condition === undefined &&
+    selectTurbopackConfigLoaders(rule).some((loader) =>
+      referencesTtscLoader(loader, resolvedLoaderResults),
+    )
   );
 }
+
+/** Whether one collection item is a direct Turbopack loader. */
+function isTurbopackLoaderItem(item: unknown): boolean {
+  return (
+    typeof item === "string" ||
+    (typeof item === "object" &&
+      item !== null &&
+      typeof (item as { loader?: unknown }).loader === "string")
+  );
+}
+
+/** Whether one Turbopack loader entry is already this package's loader. */
+function referencesTtscLoader(
+  loader: unknown,
+  resolvedLoaderResults: Map<string, boolean>,
+): boolean {
+  const identity =
+    typeof loader === "string"
+      ? loader
+      : typeof loader === "object" && loader !== null
+        ? (loader as { loader?: unknown }).loader
+        : undefined;
+  return (
+    typeof identity === "string" &&
+    (identity === TURBOPACK_LOADER ||
+      isResolvedTtscLoader(identity, resolvedLoaderResults))
+  );
+}
+
+/** Whether an absolute path is the Turbopack entry of an @ttsc/unplugin copy. */
+function isResolvedTtscLoader(
+  identity: string,
+  resolvedLoaderResults: Map<string, boolean>,
+): boolean {
+  const cached = resolvedLoaderResults.get(identity);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let file: string;
+  try {
+    file = /^file:/i.test(identity) ? fileURLToPath(identity) : identity;
+  } catch {
+    resolvedLoaderResults.set(identity, false);
+    return false;
+  }
+  if (!path.isAbsolute(file)) {
+    resolvedLoaderResults.set(identity, false);
+    return false;
+  }
+  let resolvedFile: string;
+  try {
+    resolvedFile = fs.realpathSync.native(file);
+    if (!fs.statSync(resolvedFile).isFile()) {
+      resolvedLoaderResults.set(identity, false);
+      return false;
+    }
+  } catch {
+    resolvedLoaderResults.set(identity, false);
+    return false;
+  }
+  const packageRoot = path.dirname(path.dirname(resolvedFile));
+  const relative = path
+    .relative(packageRoot, resolvedFile)
+    .replaceAll(path.sep, "/");
+  if (relative !== "lib/turbopack.js" && relative !== "lib/turbopack.mjs") {
+    resolvedLoaderResults.set(identity, false);
+    return false;
+  }
+  let matches = false;
+  try {
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"),
+    ) as { name?: unknown };
+    matches = manifest.name === "@ttsc/unplugin";
+  } catch {
+    // An unreadable or malformed owner cannot prove this package's identity.
+  }
+  resolvedLoaderResults.set(identity, matches);
+  return matches;
+}