@ttsc/unplugin 0.28.2 → 0.28.4

package/lib/core/index.mjs

@@ -2,15 +2,20 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createUnplugin } from 'unplugin';
 import { resolveOptions } from './options.mjs';
-import { createTtscTransformCache, stripQuery, transformTtsc, beginTtscTransformBuild, isDeclarationFile, resetTtscTransformCache } from './transform.mjs';
+import { createTtscTransformCache, stripQuery, transformTtsc, beginTtscTransformBuild, resetTtscTransformCache, isDeclarationFile } from './transform.mjs';
 export { collectExternalInputHashes, collectProjectInputHashes, isProjectWalkPath } from './transform.mjs';
 import { createViteServeMissingInputWatch } from './viteServe.mjs';
+export { mergeMembershipPolicyOverlay, readProjectMembershipPolicy } from './tsconfigPaths.mjs';
 
 const name = "ttsc-unplugin";
 /**
- * Matches any TypeScript or JavaScript source extension (.ts, .tsx, .mts, .cts,
- * etc.). Shared with the Bun adapter (`bun.ts`) so the filter is defined once
- * and both adapters stay in sync.
+ * Matches the TypeScript source extensions the ttsc transform handles: `.ts`,
+ * `.tsx`, `.mts`, `.cts` and their `x` forms. JavaScript is deliberately not
+ * among them, so a `.js` module reaches no adapter's transform.
+ *
+ * Shared with the Bun adapter (`bun.ts`) and the standalone Turbopack loader
+ * (`turbopack.ts`) through {@link isTransformTarget}, so the filter is defined
+ * once and every adapter answers the same way.
  */
 const sourceFilePattern = /\.[cm]?tsx?$/;
 /** Matches any path segment that is a `node_modules` directory (cross-platform). */
@@ -24,13 +29,15 @@ const virtualModulePattern = /\0/;
  * Unplugin factory that wires the ttsc transform pipeline into any supported
  * bundler (Vite, Rollup, Rolldown, webpack, Rspack, esbuild, Farm).
  *
- * The factory resolves raw options once, creates a per-build transform cache,
- * and captures Vite alias configuration via the `vite.configResolved` hook so
- * that path aliases are forwarded to the generated tsconfig overlay. Real build
- * lifecycles use a per-build cache; a watching Vite development server keeps
- * persistent validation because its one `buildStart` spans later HMR edits,
- * while a dev server configured without a watcher takes the build-scoped path
- * with them, having declared it will observe no edit at all.
+ * The factory resolves raw options once, creates one transform cache for the
+ * whole plugin instance, and captures Vite alias configuration via the
+ * `vite.configResolved` hook so that path aliases are forwarded to the
+ * generated tsconfig overlay. A host with a real `buildStart` opens a delivery
+ * pass there and keeps its generation across passes; a watching Vite
+ * development server keeps persistent validation instead, because its one
+ * `buildStart` spans later HMR edits and so cannot mark a pass, while a dev
+ * server configured without a watcher takes the pass lifecycle with them,
+ * having declared it will observe no edit at all.
  */
 const unpluginFactory = (rawOptions = {}) => {
     const options = resolveOptions(rawOptions);
@@ -39,6 +46,17 @@ const unpluginFactory = (rawOptions = {}) => {
     let aliases;
     let viteCommand;
     let viteWatching = true;
+    // Whether a build-mode session is driven by Rollup's watcher. `build.watch`
+    // is `null` for an ordinary build and an object under `--watch`, which is the
+    // axis the disposal boundary actually turns on: only a watching build repeats
+    // its build phase, and only a watching build ends at `closeWatcher`.
+    let viteBuildWatching = false;
+    // A restart can start the replacement plugin container before closing the
+    // old one, and Vite calls buildEnd even for a container that never started.
+    // Track the stable per-container PluginContext identity so that unstarted
+    // old containers cannot dispose a replacement's freshly initialized cache.
+    let viteBuildOwners = new WeakSet();
+    let viteBuildLifecycles = 0;
     return {
         name,
         enforce: "pre",
@@ -60,6 +78,13 @@ const unpluginFactory = (rawOptions = {}) => {
                 // (samchon/ttsc#1246).
                 viteWatching =
                     config.server?.watch !== null;
+                // Read on the same principle as the line above, from the half of the
+                // config that governs a build rather than a server. The comparison is
+                // loose where the server's is strict because the two defaults differ:
+                // `server.watch` is an object unless explicitly `null`, while
+                // `build.watch` is absent or `null` unless `--watch` supplies one.
+                viteBuildWatching =
+                    config.build?.watch != null;
             },
             // Vite serve funnels every transform-context `addWatchFile()` into the
             // module's added-import graph (`_addedImports`), which import-analysis
@@ -70,13 +95,90 @@ const unpluginFactory = (rawOptions = {}) => {
             configureServer(server) {
                 missingInputs.attach(server);
             },
-            // Vite calls buildEnd when the dev server (or build) closes; drop every
-            // poller so a stopped server leaks no watch state.
+            // 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
+            // overlapping container has closed, every generation-owned filesystem
+            // tracker as well.
+            //
+            // Disposing here is right wherever the end of a build phase is also the
+            // end of the session: a dev server, and an ordinary one-shot build. It is
+            // wrong for a watching build, whose watcher repeats build phases, so it
+            // means "this pass ended" there — measured as
+            // `buildStart -> buildEnd -> ... -> buildStart -> buildEnd` across
+            // `vite build --watch` rebuilds. Disposing on that repeat discarded the
+            // generation once per rebuild independently of the `buildStart` clear, so
+            // 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() {
                 missingInputs.dispose();
+                if (viteBuildOwners.delete(this)) {
+                    viteBuildLifecycles -= 1;
+                }
+                if (viteBuildLifecycles === 0 &&
+                    (viteCommand === "serve" || !viteBuildWatching)) {
+                    resetTtscTransformCache(transformCache);
+                }
+            },
+            // The watching build's real teardown, and the only hook in a
+            // `vite build --watch` trace that fires exactly once: buildEnd,
+            // writeBundle and closeBundle all repeat per rebuild there. A generation
+            // retained across passes owns directory watchers, so this is where they
+            // are released. Vite's dev server drives no Rollup watcher and an
+            // ordinary build closes its bundle instead, so neither reaches here;
+            // a host that fired both would simply reset twice, which is idempotent.
+            //
+            // The container bookkeeping is cleared with the cache, and the owner set
+            // is replaced rather than merely zeroed alongside it. A watcher closed
+            // mid-rebuild leaves a container still registered, and its later
+            // `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() {
+                viteBuildOwners = new WeakSet();
+                viteBuildLifecycles = 0;
+                resetTtscTransformCache(transformCache);
+            },
+        },
+        // Rollup and Rolldown carry none of the Vite block's hooks, so before this
+        // they had no disposal site at all. They get both halves of the same
+        // boundary: a watching session ends at `closeWatcher`, and a one-shot build
+        // ends when its build phase does. `this.meta.watchMode` separates the two
+        // there, the way `build.watch` does for Vite, so a one-shot build is not
+        // left without a site the way `vite build` was (samchon/ttsc#1301).
+        // unplugin merges each of these blocks only into its own adapter, so the
+        // Vite adapter never receives them.
+        //
+        // A `buildEnd` at the top level instead of inside a block would be a
+        // regression rather than a shorthand: unplugin forwards a top-level one to
+        // esbuild's `onEnd` and to webpack's and Rspack's `hooks.emit`, each of
+        // which repeats per rebuild, so those hosts would start discarding a valid
+        // generation on every edit, which is samchon/ttsc#1300 again.
+        rollup: {
+            buildEnd() {
+                if (this.meta?.watchMode !== true) {
+                    resetTtscTransformCache(transformCache);
+                }
+            },
+            closeWatcher() {
+                resetTtscTransformCache(transformCache);
+            },
+        },
+        rolldown: {
+            buildEnd() {
+                if (this.meta?.watchMode !== true) {
+                    resetTtscTransformCache(transformCache);
+                }
+            },
+            closeWatcher() {
+                resetTtscTransformCache(transformCache);
             },
         },
         buildStart() {
+            if (viteCommand !== undefined && !viteBuildOwners.has(this)) {
+                viteBuildOwners.add(this);
+                viteBuildLifecycles += 1;
+            }
             // Persistent validation exists for a session that spans edits it can
             // observe, and a dev server told to open no watcher is not one:
             // `server.watch: null` leaves Vite with no change channel at all, so no
@@ -84,14 +186,18 @@ const unpluginFactory = (rawOptions = {}) => {
             // no client is hot-updated. Validating each delivery there does not buy
             // freshness, it buys incoherence — modules delivered before an edit and
             // after it would come from two different compilations of one program —
-            // while costing a full derived-input proof per delivered module. The
-            // build-scoped lifecycle settles each module's first delivery against the
-            // generation the session started from, exactly as a build does, and still
+            // while costing a full derived-input proof per delivered module. The pass
+            // lifecycle settles each module's first delivery against the generation
+            // the session started from, exactly as a build does, and still
             // revalidates a module this session already delivered. A one-shot suite
             // configures precisely this server (`vitest --run` sets `server.watch =
             // null`) and is the workload behind samchon/ttsc#970
             // (samchon/ttsc#1260). The neighbouring watch-registration decision reads
             // the same two properties for the same reason.
+            //
+            // Opening a pass no longer discards the generation, so the `else` branch
+            // is what every host with a repeating `buildStart` takes without paying a
+            // whole-project transform per rebuild (samchon/ttsc#1300).
             if (viteCommand === "serve" && viteWatching) {
                 resetTtscTransformCache(transformCache);
             }
@@ -157,10 +263,15 @@ const unpluginFactory = (rawOptions = {}) => {
 };
 const unplugin = createUnplugin(unpluginFactory);
 /**
- * Returns `true` when the module id refers to a real TypeScript/JavaScript
- * source file that should be processed by the ttsc transform.
+ * Returns `true` when the module id refers to a real TypeScript source file
+ * that should be processed by the ttsc transform.
+ *
+ * TypeScript only. {@link sourceFilePattern} deliberately excludes JavaScript,
+ * so a `.js` module reaches no adapter's transform, and this docstring used to
+ * say otherwise while the pattern it is built from said the truth
+ * (samchon/ttsc#1309).
  *
- * Excluded ids: virtual modules (NUL prefix), `.d.ts` declaration files, and
+ * Also excluded: virtual modules (NUL prefix), `.d.ts` declaration files, and
  * anything inside `node_modules`.
  */
 function isTransformTarget(id) {

package/lib/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"index.mjs","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/core/transform.d.cts

@@ -3,6 +3,7 @@ import type { ITtscCompilerTransformation } from "ttsc";
 import { type FilesystemPathIdentityContext, type FilesystemPathIdentityOperations } from "ttsc/path-identity";
 import type { TransformResult } from "unplugin";
 import type { ResolvedTtscUnpluginOptions } from "./options.cjs";
+import { type ITtscProjectMembershipPolicy } from "./tsconfigPaths.cjs";
 /**
  * The normalised transform result type that this module produces.
  *
@@ -11,26 +12,39 @@ import type { ResolvedTtscUnpluginOptions } from "./options.cjs";
  * `undefined`.
  */
 export type TtscTransformResult = Exclude<TransformResult, string | null | undefined>;
-/**
- * Normalised alias entry used when building the `paths` overlay for the
- * generated tsconfig. Derived from either a Vite array alias or a webpack/
- * Rspack object alias.
- */
-export interface TtscTransformAlias {
-    /** The alias key (module specifier prefix). */
-    find: string;
-    /** Absolute or cwd-relative path that the alias points to. */
-    replacement: string;
-}
-/** One directory's cheap project-membership identity at generation time. */
+/** One directory's project-membership identity at generation time. */
 interface TtscProjectDirectorySnapshot {
     /** Absolute directory spelling used by the project walk. */
     path: string;
-    /** Metadata signature that changes when its immediate membership changes. */
+    /**
+     * Whether this directory's subtree can hold a program input.
+     *
+     * A directory that cannot is still walked and still watched, so a source
+     * appearing in it later is noticed, but it takes no part in the membership
+     * comparison. That is what lets a bundler create its output directory and
+     * fill it without voiding a generation no compiler input touched, for any
+     * output directory rather than for fifteen names (samchon/ttsc#1307).
+     */
+    relevant: boolean;
+    /**
+     * Digest of the entries the walk itself considers: every immediate child the
+     * ignore list does not drop, with its kind.
+     *
+     * Deliberately not the directory's own metadata. A directory's stamp moves
+     * whenever _any_ entry is added or removed, including the ones the walk
+     * exists to ignore, so a bundler emitting into `dist/` — or merely creating
+     * that directory for the first time — moved the project root's stamp and
+     * voided a generation that no compiler input had touched. The ignore list
+     * only protects the generation if the membership proof honours it too.
+     */
     signature: string;
 }
 /** Generation-scoped directory watchers used to detect membership changes. */
 interface TtscProjectMutationTracker {
+    /** Absolute paths named by generation-time mutation events. */
+    changes: Set<string>;
+    /** Whether additional event paths were discarded after the witness bound. */
+    changesOmitted: boolean;
     close: () => void;
     /**
      * Absolute spellings whose creation, change or removal this tracker would
@@ -113,6 +127,28 @@ export interface TtscCachedProjectTransform {
      * transform.
      */
     inputHashes: Record<string, string>;
+    /**
+     * What the resolved configuration admitted into this generation's program.
+     *
+     * Recorded per generation rather than read per validation because it is a
+     * property of the configuration the compile ran under, so a later delivery
+     * must judge membership by the same rule the compile did. A tsconfig edit
+     * that changes the rule also changes a declared input, which replaces the
+     * generation and its policy together.
+     */
+    membershipPolicy: ITtscProjectMembershipPolicy;
+    /**
+     * Files already reported as absent from the program, and the pass that
+     * reporting belongs to, so the notice is one per file per pass rather than
+     * one per delivery.
+     */
+    missingOutputReported?: Set<string>;
+    missingOutputEpoch?: number;
+    /**
+     * The project config this generation compiled, so a module the program does
+     * not contain can be told which program that was.
+     */
+    tsconfig: string;
     /**
      * Metadata signature of each {@link inputHashes} entry whose hash was proven
      * against an unracing read of the file on disk, in a tick the observed
@@ -124,6 +160,13 @@ export interface TtscCachedProjectTransform {
      * disk bytes against the recorded hash, and may record a signature then.
      */
     inputSignatures?: Record<string, string>;
+    /**
+     * Raw source hash of every readable key in the transform output, keyed by
+     * filesystem identity. Unlike {@link inputHashes}, this includes source
+     * outputs outside the project walk without adding arbitrary output keys to
+     * the complete project snapshot.
+     */
+    sourceHashes?: Record<string, string>;
     /** Metadata snapshot of every directory in the stable generation walk. */
     projectDirectories?: TtscProjectDirectorySnapshot[];
     /** Live notification state for universal host-input changes. */
@@ -168,19 +211,50 @@ export interface TtscCachedProjectTransform {
     projectRoot: string;
     /** Raw compiler output returned by {@link TtscCompiler.transform}. */
     result: ITtscCompilerTransformation;
+    /**
+     * The delivery epoch this generation is currently settled against, or
+     * `undefined` for a generation no epoch has proven.
+     *
+     * Set when the generation is compiled, and again whenever a later epoch's
+     * first delivery proves the whole generation still matches the filesystem.
+     * While it equals the cache's current epoch, each module's first delivery is
+     * settled by the supplied source alone, exactly as it was when every pass
+     * compiled its own generation (samchon/ttsc#1300).
+     */
+    deliveryEpoch?: number;
+    /**
+     * Whether this generation's non-error diagnostics have been surfaced at all,
+     * and the epoch they were last surfaced in.
+     *
+     * The diagnostics describe one compile of one program, so they belong to the
+     * generation rather than to a delivery; a pass that reuses a retained
+     * generation still surfaces them once, because a build's warnings are part of
+     * what that build reports (samchon/ttsc#1304). The two fields are separate so
+     * a persistent host, whose epoch is `undefined`, still reports the first
+     * time.
+     */
+    diagnosticsReported?: boolean;
+    diagnosticsEpoch?: number;
     /**
      * Files already delivered from this generation, keyed by filesystem identity.
-     * Build-scoped caches use this to skip persistent validation only for a
-     * module's first delivery inside the current build.
+     * A cache with a delivery epoch uses this to skip persistent validation only
+     * for a module's first delivery inside the current pass; the set is cleared
+     * whenever a new epoch's gate re-proves the generation.
      */
     servedFiles?: Set<string>;
+    /**
+     * Absolute path of the adapter-owned scratch directory used for this
+     * generation. It is disposed after compilation, so none of its compiler,
+     * resolver, or plugin artifacts can be a persistent cache or watch input.
+     */
+    scratchDirectory?: string;
     /**
      * 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.
+     * bundler cache snapshot on the next build; watch derivation must skip this
+     * path. {@link scratchDirectory} owns the wider disposable-input bound.
      */
     temporaryTsconfig?: string;
 }
@@ -234,20 +308,31 @@ export declare function normalizeHostInputName(name: string, caseSensitive: bool
 /** Create an empty persistent transform cache with isolated filesystem reads. */
 export declare function createTtscTransformCache(operations?: Partial<TtscTransformFilesystemOperations>): TtscTransformCache;
 /**
- * Start a host build, clearing its prior generation and enabling constant-time
- * first delivery for modules compiled during this build.
+ * Open a new delivery pass, enabling constant-time first delivery for every
+ * module this pass asks for.
+ *
+ * This deliberately retains the cached generation. The pass boundary is a
+ * statement about _deliveries_ — each module is requested at most once inside
+ * it — not about whether the compiled program is still correct, which the
+ * generation's own recorded snapshot answers and which
+ * {@link matchesCachedSource} proves once at the pass's first delivery. Clearing
+ * here instead made a host whose `buildStart` repeats recompile the whole
+ * project on every rebuild even when no compiler input had changed
+ * (samchon/ttsc#1300). Use {@link resetTtscTransformCache} to actually discard a
+ * generation and its watchers.
  *
- * Hosts without a guaranteed build-start callback use persistent validation
- * unless they have another immutable lifecycle. Bun runtime setup, for example,
+ * Hosts without a guaranteed pass boundary use persistent validation unless
+ * they have another immutable lifecycle. Bun runtime setup, for example,
  * defines one process-scoped module-loading session.
  */
 export declare function beginTtscTransformBuild(cache: TtscTransformCache): void;
 /**
- * Clear a cache and return it to persistent validation mode.
+ * Discard every generation, dispose its watchers, and return the cache to
+ * persistent validation mode.
  *
- * This is distinct from {@link beginTtscTransformBuild}: hosts such as Vite's
- * development server may invoke `buildStart` only once for a process that spans
- * many edits, so that callback cannot authorize build-scoped shortcuts.
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * {@link beginTtscTransformBuild}: a pass ending is not a reason to throw a
+ * proven compile away, while a session ending is.
  */
 export declare function resetTtscTransformCache(cache: TtscTransformCache): void;
 /**
@@ -365,8 +450,10 @@ interface TtscHostInputValidation {
  */
 export declare function stripQuery(id: string): string;
 /**
- * Returns `true` for TypeScript declaration files (`.d.ts`, `.d.mts`,
- * `.d.cts`).
+ * Returns `true` for every declaration-file spelling TypeScript-Go accepts.
+ * Besides the standard `.d.ts`, `.d.mts`, and `.d.cts` forms, TypeScript-Go
+ * treats an arbitrary-extension source such as `styles.d.css.ts` as a
+ * declaration file too.
  */
 export declare function isDeclarationFile(id: string): boolean;
 /**
@@ -383,7 +470,7 @@ export declare function createTransformResult(source: string, code: string): Tts
  * slash path. Exported so hosts without a per-build boundary (`@ttsc/metro`)
  * can fold the identical input universe into their own cache fingerprints.
  */
-export declare function collectProjectInputHashes(projectRoot: string, identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations): Record<string, string>;
+export declare function collectProjectInputHashes(projectRoot: string, identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): Record<string, string>;
 /**
  * Report whether an absolute `file` belongs to the project walk universe of
  * `root`: it lies under `root`, every component exists without traversing a
@@ -393,7 +480,7 @@ export declare function collectProjectInputHashes(projectRoot: string, identitie
  * Missing paths and files reached through symlinks or Windows junctions are
  * out-of-walk inputs that only the reference graph can prove relevant.
  */
-export declare function isProjectWalkPath(root: string, file: string, _identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations): boolean;
+export declare function isProjectWalkPath(root: string, file: string, _identities?: FilesystemPathIdentityContext, filesystem?: TtscTransformFilesystemOperations, policy?: ITtscProjectMembershipPolicy): boolean;
 /**
  * Hash a list of absolute out-of-walk input paths: content SHA-256 for a
  * readable file, a stable directory-kind digest for a directory candidate, and