@ttsc/unplugin 0.30.2 → 0.30.3

package/src/core/index.ts

@@ -1,8 +1,7 @@
-import fs from "node:fs";
-import path from "node:path";
 import type { UnpluginFactory, UnpluginInstance } from "unplugin";
 import { createUnplugin } from "unplugin";
 
+import { createEsbuildOptions } from "./esbuild";
 import type { TtscUnpluginOptions } from "./options";
 import { resolveOptions } from "./options";
 import { typescriptTransformSourcePattern } from "./sourceExtensions";
@@ -22,7 +21,7 @@ import {
   transformTtsc,
   watchInputEvidenceMatchesBaseline,
 } from "./transform";
-import { createViteServeMissingInputWatch } from "./viteServe";
+import { createViteServeInputWatch } from "./viteServe";
 
 const name = "ttsc-unplugin";
 /**
@@ -60,10 +59,13 @@ const virtualModulePattern = /\0/;
 const unpluginFactory: UnpluginFactory<
   TtscUnpluginOptions | undefined,
   false
-> = (rawOptions = {}) => {
+> = (rawOptions = {}, meta) => {
   const options = resolveOptions(rawOptions);
+  if (meta.framework === "esbuild") {
+    return createEsbuildOptions(options, isTransformTarget);
+  }
   const transformCache = createTtscTransformCache();
-  const missingInputs = createViteServeMissingInputWatch();
+  const serveInputs = createViteServeInputWatch();
   let aliases: unknown;
   let viteCommand: string | undefined;
   let viteWatching = true;
@@ -78,13 +80,6 @@ const unpluginFactory: UnpluginFactory<
   // old containers cannot dispose a replacement's freshly initialized cache.
   let viteBuildOwners = new WeakSet<object>();
   let viteBuildLifecycles = 0;
-  // esbuild schedules one-shot onDispose callbacks after it settles the build
-  // Promise. Acquire ownership only at onStart: plugin setup runs before build
-  // option validation, and a validation failure has no onDispose callback with
-  // which to release a setup-time owner. Once a build has actually started, the
-  // count keeps an older delayed callback from disposing its active generation.
-  const esbuildOwners = new WeakSet<object>();
-  let esbuildLifecycles = 0;
 
   return {
     name,
@@ -116,14 +111,11 @@ const unpluginFactory: UnpluginFactory<
         viteBuildWatching =
           (config as { build?: { watch?: unknown } }).build?.watch != null;
       },
-      // Vite serve funnels every transform-context `addWatchFile()` into the
-      // module's added-import graph (`_addedImports`), which import-analysis
-      // resolves like real imports. Capture the dev server so the transform
-      // hook can route watch inputs that do not exist yet — superseding
-      // resolution candidates above all — around that graph and still
-      // invalidate their importers when the path is created.
+      // Compiler dependencies belong to the filesystem watch graph. Vite's
+      // transform-context addWatchFile also inserts runtime imports, so none
+      // of those dependencies may use that channel during serve (#1368).
       configureServer(server) {
-        missingInputs.attach(server);
+        serveInputs.attach(server);
       },
       // Vite calls buildEnd when the dev server closes, and Rollup calls it at
       // the end of every build phase; drop every poller and, once the last
@@ -140,15 +132,15 @@ const unpluginFactory: UnpluginFactory<
       // fixing one of the two sites alone left this host recompiling the whole
       // project per edit (samchon/ttsc#1301). The watching build hands its
       // teardown to `closeWatcher` below instead.
-      buildEnd() {
+      async buildEnd() {
         if (viteBuildOwners.delete(this)) {
           viteBuildLifecycles -= 1;
         }
         if (viteBuildLifecycles === 0) {
-          missingInputs.dispose();
           if (viteCommand === "serve" || !viteBuildWatching) {
             resetTtscTransformCache(transformCache);
           }
+          await serveInputs.dispose();
         }
       },
       // The watching build's real teardown, and the only hook in a
@@ -165,11 +157,11 @@ const unpluginFactory: UnpluginFactory<
       // `buildEnd` would then decrement a counter that is already zero and
       // strand it below zero, after which the disposal above could never fire
       // again for this plugin instance.
-      closeWatcher() {
+      async closeWatcher() {
         viteBuildOwners = new WeakSet<object>();
         viteBuildLifecycles = 0;
-        missingInputs.dispose();
         resetTtscTransformCache(transformCache);
+        await serveInputs.dispose();
       },
     },
 
@@ -221,26 +213,16 @@ const unpluginFactory: UnpluginFactory<
         resetTtscTransformCache(transformCache);
       });
     },
-    esbuild: {
-      setup(build) {
-        build.onStart(() => {
-          if (!esbuildOwners.has(build)) {
-            esbuildOwners.add(build);
-            esbuildLifecycles += 1;
-          }
-        });
-        build.onDispose(() => {
-          if (!esbuildOwners.delete(build)) {
-            return;
-          }
-          esbuildLifecycles -= 1;
-          if (esbuildLifecycles === 0) {
-            resetTtscTransformCache(transformCache);
-          }
-        });
+    farm: {
+      // Farm calls buildStart only for the initial compilation. Every update
+      // opens a new pass so a failed verdict can recover, while an unchanged
+      // successful generation remains reusable across its module deliveries.
+      updateModules: {
+        executor() {
+          beginTtscTransformBuild(transformCache);
+        },
       },
     },
-
     buildStart() {
       if (viteCommand !== undefined && !viteBuildOwners.has(this as object)) {
         viteBuildOwners.add(this as object);
@@ -283,65 +265,34 @@ const unpluginFactory: UnpluginFactory<
         return undefined;
       }
       return transformTtsc(file, source, options, aliases, transformCache, {
-        // 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. Under Vite serve a
-        // resolver input that is not proven to be a file must not enter
-        // `addWatchFile`: import-analysis resolves added imports and 500s on
-        // missing paths and directories, so those are watched against their
-        // compiler predicates instead and invalidate this module when the
-        // observation changes.
-        addWatchFile: (watched, evidence) => {
-          if (viteCommand === "serve" && missingInputs.serving()) {
-            const observation =
-              evidence?.state?.codec === "predicates"
-                ? evidence.state.observation
-                : undefined;
-            const unsafePredicate =
-              observation !== undefined &&
-              observation.fileExists !== true &&
-              observation.stat !== "file" &&
-              observation.readFile?.ok !== true
-                ? observation
-                : undefined;
-            if (unsafePredicate !== undefined) {
-              missingInputs.watch(watched, path.resolve(file), unsafePredicate);
-              return;
-            }
-            // Trust the generation's recorded existence when it supplied one:
-            // every cache hit revalidates it, and probing each input again
-            // costs one `existsSync` per input per delivered module.
-            const unavailable =
-              evidence?.unavailable ??
-              (evidence === undefined
-                ? !fs.existsSync(watched)
-                  ? "missing"
-                  : undefined
-                : evidence.missing
-                  ? "missing"
-                  : undefined);
-            if (unavailable !== undefined) {
-              missingInputs.watch(
-                watched,
-                path.resolve(file),
-                unavailable === "not-file" ? "file" : "exists",
-              );
-              return;
-            }
-          }
-          // A dev server configured without a watcher can never deliver a
-          // change event, so a registration here buys nothing, and it is not
-          // free: Vite's import analysis resolves every registered path like a
-          // real import of the transformed module, once per module. The
-          // adapter's own missing-input poll above stays active either way,
-          // because it never depended on Vite's watcher.
-          if (viteCommand === "serve" && !viteWatching) {
-            return;
-          }
-          this.addWatchFile(watched);
-        },
+        // A watcherless server has no invalidation channel and needs no
+        // watch-input derivation. Every other host keeps its native contract.
+        addWatchFiles:
+          viteCommand === "serve" && !viteWatching
+            ? undefined
+            : (inputs, failed) => {
+                if (viteCommand === "serve") {
+                  serveInputs.replace(file, inputs, failed);
+                } else {
+                  const native = this.getNativeBuildContext?.();
+                  for (const input of inputs) {
+                    if (
+                      native?.framework === "rspack" &&
+                      native.loaderContext !== undefined
+                    ) {
+                      // Compilation-level dependencies schedule a pass but do
+                      // not invalidate Rspack's cached transformed modules.
+                      if (input.evidence?.missing === true)
+                        native.loaderContext.addMissingDependency(input.file);
+                      else native.loaderContext.addDependency(input.file);
+                    } else if (native?.framework === "farm") {
+                      native.context.addWatchFile(file, input.file);
+                    } else {
+                      this.addWatchFile(input.file);
+                    }
+                  }
+                }
+              },
         // 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.

package/src/core/transform.ts

@@ -239,14 +239,13 @@ class TtscUnstableGenerationError extends TtscTerminalGenerationError {
 /**
  * A compile this pass already attempted, whose envelope failed outright.
  *
- * The envelope cannot say whether the host reported diagnostics about the
- * project or failed to run at all: an ordinary type error arrives as an
- * `"exception"` carrying the compiler's own diagnostic text, exactly as a
- * crashed host would. Sniffing that message to tell the two apart would be a
- * guess, so the adapter uses the one boundary it genuinely owns. Inside a pass
- * the answer is already settled, so every later module replays it instead of
- * repeating a whole-project transform to reach the same verdict, which is what
- * made a single broken save cost one compile per delivered module
+ * Native project diagnostics carry a structured failure envelope; setup and
+ * host failures can still arrive as opaque exceptions. Both settle the current
+ * attempt, so the adapter uses the delivery boundary it owns rather than
+ * guessing retryability from a diagnostic message. Inside a pass the answer is
+ * already settled, so every later module replays it instead of repeating a
+ * whole-project transform to reach the same verdict, which is what made a
+ * single broken save cost one compile per delivered module
  * (samchon/ttsc#1303).
  *
  * The scope is exactly the pass. A host whose `buildStart` repeats drops the
@@ -811,10 +810,12 @@ export interface TtscTransformHooks {
   addWatchFile?: (file: string, evidence?: TtscWatchInputEvidence) => void;
   /**
    * Batched form of {@link addWatchFile}. When supplied, the transform calls it
-   * once per delivered module and does not call `addWatchFile` for that
-   * module.
+   * once per delivered module and does not call `addWatchFile` for that module.
+   * `failed` marks a recovery batch: a failed compiler can omit inputs from its
+   * previous successful result, so replacing hosts should retain those
+   * spellings until the next successful delivery.
    */
-  addWatchFiles?: (inputs: readonly TtscWatchInput[]) => void;
+  addWatchFiles?: (inputs: readonly TtscWatchInput[], failed?: boolean) => void;
   /**
    * Invoked when the plugin declared the transformed file volatile (the
    * envelope's `volatile` list): its output depends on non-file inputs that no
@@ -1947,11 +1948,11 @@ function collectDeclaredIdentities(
  * invalidated, and the error stays on screen (samchon/ttsc#1312).
  *
  * A failure envelope can retain exact external input spellings from its graph
- * and host metadata. A pre-transform typecheck failure may have no graph yet;
- * its structured diagnostics, or the host's standard diagnostic lines when it
- * could return only an exception, still name the external files that need a
- * repair. The cost is paid only on a failure, and only until the next compile
- * succeeds and narrows the set back to the derived inputs.
+ * and host metadata, including missing resolution candidates on native
+ * typecheck failures. For hosts that return no graph, structured diagnostics or
+ * standard diagnostic lines provide only the paths they actually name. The cost
+ * is paid only on a failure, and only until the next compile succeeds and
+ * narrows the set back to the derived inputs.
  */
 function notifyFailedGenerationInputs(
   hooks: TtscTransformHooks | undefined,
@@ -2002,7 +2003,7 @@ function notifyFailedGenerationInputs(
     }
   }
   if (addWatchFiles !== undefined) {
-    addWatchFiles(inputs);
+    addWatchFiles(inputs, true);
     return;
   }
   for (const input of inputs) {
@@ -5006,7 +5007,9 @@ async function registerWindowsProjectMutationTracker(
   });
   broker.pendingRegistrations += 1;
   broker.child.ref();
-  broker.child.channel?.ref();
+  // Bun's IPC channel omits Node's Control.ref/unref methods. The child itself
+  // still owns the outstanding acknowledgement on that runtime.
+  broker.child.channel?.ref?.();
   const id = broker.nextId++;
   let resolveReady!: () => void;
   const ready = new Promise<void>((resolve) => {
@@ -5071,7 +5074,7 @@ async function registerWindowsProjectMutationTracker(
     // exit mid-build.
     if (broker.pendingRegistrations === 0 && broker.pendingDrains === 0) {
       broker.child.unref();
-      broker.child.channel?.unref();
+      broker.child.channel?.unref?.();
     }
   }
 }
@@ -5199,7 +5202,7 @@ function startWindowsProjectMutationDrain(
       broker.pendingDrains -= 1;
       if (broker.pendingDrains === 0 && broker.pendingRegistrations === 0) {
         broker.child.unref();
-        broker.child.channel?.unref();
+        broker.child.channel?.unref?.();
       }
       resolve();
     };
@@ -5210,7 +5213,7 @@ function startWindowsProjectMutationDrain(
     // process exits mid-build with nothing to report.
     broker.pendingDrains += 1;
     broker.child.ref();
-    broker.child.channel?.ref();
+    broker.child.channel?.ref?.();
     const timer = setTimeout(release, WINDOWS_MUTATION_DRAIN_FALLBACK_MS);
     broker.drains.set(id, release);
     if (broker.child.send?.({ id, op: "drain" }) !== true) {
@@ -7858,13 +7861,12 @@ function formatUnknownError(error: unknown): string {
 /**
  * Remove terminal colour and cursor sequences from text the adapter surfaces.
  *
- * An ordinary type error reaches the adapter as an `"exception"` envelope whose
- * `error` is the host's own rendered output, colour and all, and the envelope
- * carries no structured diagnostics to format instead. What the adapter hands
- * back is not going to a terminal: it becomes the `Error` a bundler reports, so
- * it lands in a Vite overlay, a webpack error report or a CI annotation, where
- * the escapes render as literal noise around the file and line the reader needs
- * (samchon/ttsc#1312).
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs (samchon/ttsc#1312).
  *
  * The colour originates in the host's rendering rather than in anything this
  * adapter configures, so this is the adapter-side repair, applied to every