@ttsc/unplugin 0.30.4 → 0.31.1

package/lib/core/unplugin.mjs

@@ -0,0 +1,552 @@
+import { createUnplugin } from 'unplugin';
+import { buildHostDeclaresPolling } from './bridge/buildHostDeclaresPolling.mjs';
+import { resolveConfiguredHostRoot, selectBuildHostRoot } from './bridge/buildHostRoot.mjs';
+import { createBuildWatchFile } from './bridge/createBuildWatchFile.mjs';
+import { fallbackToolDirectory } from './bridge/fallbackToolDirectory.mjs';
+import { hostToolDirectory } from './bridge/hostToolDirectory.mjs';
+import { openHostWatchBridge } from './bridge/openHostWatchBridge.mjs';
+import { refreshProjectRecordFiles } from './bridge/refreshProjectRecordFiles.mjs';
+import { registerProjectRecord } from './bridge/registerProjectRecord.mjs';
+import { createEsbuildOptions } from './esbuild/createEsbuildOptions.mjs';
+import { farmPersistentCacheWithoutRecords } from './farm/farmPersistentCacheWithoutRecords.mjs';
+import { farmRecordFallback } from './farm/farmRecordFallback.mjs';
+import { isTransformTarget } from './isTransformTarget.mjs';
+import { resolveOptions } from './options/resolveOptions.mjs';
+import { createRollupCachedModuleProof } from './rollup/createRollupCachedModuleProof.mjs';
+import { rollupDeliveryOptions } from './rollup/rollupDeliveryOptions.mjs';
+import { selectRollupCachedModuleTransform } from './rollup/selectRollupCachedModuleTransform.mjs';
+import { createAliasPaths } from './transform/alias/createAliasPaths.mjs';
+import { beginTtscTransformBuild } from './transform/cache/beginTtscTransformBuild.mjs';
+import { createTtscTransformCache } from './transform/cache/createTtscTransformCache.mjs';
+import { declareTtscTransformPolling } from './transform/cache/declareTtscTransformPolling.mjs';
+import { resetTtscTransformCache } from './transform/cache/resetTtscTransformCache.mjs';
+import { sharedBuildTransformCache } from './transform/cache/sharedBuildTransformCache.mjs';
+import { hostDeclaresPolling } from './transform/tracker/hostDeclaresPolling.mjs';
+import { transformTtsc } from './transform/transformTtsc.mjs';
+import { isHostWrapperQuery } from './transform/utils/isHostWrapperQuery.mjs';
+import { stripQuery } from './transform/utils/stripQuery.mjs';
+import { createViteBuildLifecycle } from './vite/createViteBuildLifecycle.mjs';
+import { createViteServeInputWatch } from './vite/createViteServeInputWatch.mjs';
+import { createViteServeWatchHooks } from './vite/createViteServeWatchHooks.mjs';
+import { TTSC_SOURCE_MAP_STASH } from './webpack/TTSC_SOURCE_MAP_STASH.mjs';
+import { registerTtscSourceMapLoader } from './webpack/registerTtscSourceMapLoader.mjs';
+import { reportCompiledProjectRecords } from './webpack/reportCompiledProjectRecords.mjs';
+
+const name = "ttsc-unplugin";
+/**
+ * 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 one transform cache for the
+ * whole plugin instance (or, for webpack and Rspack, shares the one every
+ * compiler with equal options uses), 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.
+ *
+ * Build-host observation belongs to its active watch session. Watch closure
+ * retires that bridge before a reused compiler can begin another session with
+ * different polling options; the shared generation lease still belongs to the
+ * compiler and ends at shutdown.
+ */
+const unpluginFactory = (rawOptions = {}, meta) => {
+    const options = resolveOptions(rawOptions);
+    if (meta.framework === "esbuild") {
+        return createEsbuildOptions(options, isTransformTarget);
+    }
+    // webpack and Rspack call this factory once per compiler, so the client,
+    // server, and edge compilers of one Next build each compiled the same
+    // program. Equal options share one process-wide cache, whose lease spans
+    // all of their sessions (samchon/ttsc#1396).
+    const shared = meta.framework === "webpack" || meta.framework === "rspack"
+        ? sharedBuildTransformCache(JSON.stringify(options))
+        : undefined;
+    shared?.lease.acquire();
+    const transformCache = shared?.cache ?? createTtscTransformCache();
+    // A non-watching Vite build keeps its generation from one environment's
+    // build to the next instead of compiling the program again for each.
+    const viteLifecycle = createViteBuildLifecycle(transformCache);
+    const serveInputs = createViteServeInputWatch();
+    let aliases;
+    // The observer a watching build gets for the compiler predicates its own
+    // channel cannot observe, opened by the session's first watching delivery
+    // and closed where the session ends (samchon/ttsc#1388).
+    let bridge;
+    // The bridge's change sequence when the current pass opened. A pass proves
+    // the generation once, at its first delivery, and serves every later module
+    // of the pass from it, so a delivery may carry a state a change since the
+    // pass opened has left, however late its own transform began. Registration
+    // proves each input against changes since this token, not since the
+    // transform, which would have answered the bridge's signal with the stale
+    // delivery itself (samchon/ttsc#1460).
+    let passStartedAt;
+    // Farm reports no watch mode to a transform. Its development mode is the one
+    // that watches: `farm start` and `farm watch` resolve it, `farm build` does
+    // not.
+    let farmWatching;
+    // Farm's configured root, which Farm relates every watch file to and cannot
+    // relate one on another Windows drive to, so its record lives below it, as
+    // the Turbopack loader's lives below the root Turbopack resolved. Every other
+    // host this factory serves takes any path, and its record lives below the
+    // directory it runs in.
+    let farmRoot;
+    const hostRoot = () => selectBuildHostRoot(farmRoot);
+    // Where a host that cannot write below its root keeps its records
+    // (samchon/ttsc#1480): below this user's temporary directory, which every
+    // host this factory serves accepts but Farm on another drive.
+    const recordFallback = () => {
+        const fallback = farmRoot !== undefined
+            ? farmRecordFallback(farmRoot)
+            : fallbackToolDirectory(hostRoot());
+        return fallback === undefined ? {} : { fallbackToolDirectory: fallback };
+    };
+    const recordDirectories = () => [
+        hostToolDirectory(hostRoot()),
+        ...Object.values(recordFallback()),
+    ];
+    const closeBridge = async () => {
+        const open = bridge;
+        bridge = undefined;
+        passStartedAt = undefined;
+        await open?.close();
+    };
+    // Whether the host watches: it then observes the compiler's inputs through
+    // the session's bridge, whose sequence token is taken before the compile,
+    // as the dev server's is. Every other host is one-shot and proves the
+    // record at its next start. Read from the context unplugin hands every hook,
+    // `buildStart` and `transform` alike.
+    const hostWatching = (context) => {
+        if (viteLifecycle.command === "serve")
+            return false;
+        const native = context.getNativeBuildContext?.();
+        return native?.framework === "webpack" || native?.framework === "rspack"
+            ? native.compiler.watchMode === true
+            : native?.framework === "farm"
+                ? farmWatching === true
+                : native === undefined && context.meta?.watchMode === true;
+    };
+    // Whether the adapter transforms a module id. A host-generated wrapper such
+    // as `?raw` is not the file's program (samchon/ttsc#1394).
+    const includes = (id) => isTransformTarget(stripQuery(id)) && !isHostWrapperQuery(id);
+    // Whether the host restores modules from a cache of its own that the adapter
+    // cannot answer module by module, so that a build start must prove every
+    // record of the tool directory, and a watching session's bridge take each,
+    // for the modules no delivery of this process produced (samchon/ttsc#1481).
+    // webpack, Rspack, and Farm keep such caches, and none says which projects
+    // it holds; webpack 5's and Rspack 2's key a module by neither the tsconfig
+    // nor any option the adapter compiled it under, measured, so an instance's
+    // own project is no bound either. Rollup, and a Vite build on Rollup, ask
+    // before they serve each module from theirs, and the adapter proves the
+    // record of the module then (`createRollupCachedModuleProof`); Rolldown and
+    // a Vite build on it keep none, nor does a dev server across a restart. A
+    // host this cannot tell apart proves every record.
+    const restoresUnanswered = (context) => viteLifecycle.command !== "serve" &&
+        (context.getNativeBuildContext?.() !== undefined ||
+            context.meta?.rollupVersion === undefined);
+    // The options a delivery to Rollup is compiled under, read again once the
+    // aliases Vite resolves change.
+    let deliveryOptions;
+    const currentDeliveryOptions = () => {
+        if (deliveryOptions === undefined || deliveryOptions.aliases !== aliases)
+            deliveryOptions = {
+                aliases,
+                identity: rollupDeliveryOptions(options, createAliasPaths(aliases)),
+            };
+        return deliveryOptions.identity;
+    };
+    // Rollup's cache, which Rollup, and a Vite build on Rollup, serve a module
+    // from after asking `shouldTransformCachedModule`; Rolldown takes neither.
+    // A build without a watching session's bridge proves the record of each
+    // project whose module Rollup is about to restore.
+    const cachedModules = createRollupCachedModuleProof(name, includes, currentDeliveryOptions, () => bridge === undefined);
+    const answersRollupCache = (context) => viteLifecycle.command !== "serve" &&
+        context.getNativeBuildContext?.() === undefined &&
+        context.meta?.rollupVersion !== undefined &&
+        context.meta.rolldownVersion === undefined;
+    // A module Rollup would serve from its cache runs again while the bridge
+    // owes the signal of a record it moved (samchon/ttsc#1460), and wherever its
+    // delivery's record moved since (`createRollupCachedModuleProof`).
+    const shouldTransformCachedModule = (module) => selectRollupCachedModuleTransform(bridge, cachedModules, module);
+    return {
+        name,
+        enforce: "pre",
+        vite: {
+            configResolved(config) {
+                // Vite resolves a root-relative replacement such as `"/src"` against
+                // its root before the filesystem, so each alias carries the root it
+                // belongs to (samchon/ttsc#1399).
+                aliases = Array.isArray(config.resolve.alias)
+                    ? config.resolve.alias.map((alias) => ({
+                        ...alias,
+                        root: config.root,
+                    }))
+                    : config.resolve.alias;
+                // Re-read per config resolution: a plugin instance reused across a
+                // serve and a later build must stop routing missing inputs to the
+                // serve-time poll, even though the closed server stays attached
+                // (see the dispose note in vite/createViteServeInputWatch.ts).
+                // `server.watch: null` disables Vite's watcher outright, which is how
+                // a one-shot consumer (a `vitest --run` suite above all) configures the
+                // dev server. Nothing can then deliver a change event, so every watch
+                // registration is dead weight, and not cheap dead weight: Vite's
+                // import analysis resolves each registered path like a real import of
+                // the transformed module, once per module, which is the dominant cost
+                // of a delivered module in a project with a real dependency graph
+                // (samchon/ttsc#1246).
+                // 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.
+                viteLifecycle.configure(config);
+                // A server told to poll has said native notifications do not work on
+                // its filesystem, so no generation may take a watcher's silence as
+                // proof there (samchon/ttsc#1395). Vite's chokidar reads the same
+                // environment override `hostDeclaresPolling` does.
+                declareTtscTransformPolling(transformCache, hostDeclaresPolling(process.env, viteLifecycle.usePolling));
+            },
+            // 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) {
+                serveInputs.attach(server);
+            },
+            watchChange(id, change) {
+                if (change.event === "delete")
+                    serveInputs.forget(stripQuery(id));
+            },
+            // 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.
+            async buildEnd() {
+                if (viteLifecycle.end(this)) {
+                    await serveInputs.dispose();
+                }
+            },
+            // 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.
+            async closeWatcher() {
+                viteLifecycle.close();
+                await serveInputs.dispose();
+                await closeBridge();
+            },
+            // A `vite build` bundles through Rollup, whose cache the Rollup block
+            // below answers; Rolldown, behind Vite 8, takes no such hook and ignores
+            // it.
+            shouldTransformCachedModule,
+        },
+        // 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);
+                }
+            },
+            async closeWatcher() {
+                resetTtscTransformCache(transformCache);
+                await closeBridge();
+            },
+            // Rollup asks here before it serves a module from its cache. A record
+            // moved while Rollup is building invalidates the cache that build
+            // started from, and the build's own result then replaces it, so the
+            // modules were served from the cache on the rerun and stayed on their
+            // old output (samchon/ttsc#1460): while the bridge owes a signal every
+            // module is transformed instead, which registers the record and answers
+            // it. A build handed a cache has no watcher at all, and its modules run
+            // again wherever their delivery's record moved since, which that build
+            // proves first.
+            shouldTransformCachedModule,
+        },
+        rolldown: {
+            buildEnd() {
+                if (this.meta?.watchMode !== true) {
+                    resetTtscTransformCache(transformCache);
+                }
+            },
+            async closeWatcher() {
+                resetTtscTransformCache(transformCache);
+                await closeBridge();
+            },
+        },
+        // These hosts map a top-level buildEnd to a per-compilation hook, so use
+        // their true compiler or context teardown instead. The custom callbacks
+        // are installed by unplugin alongside its ordinary transform wiring.
+        webpack(compiler) {
+            registerTtscSourceMapLoader(compiler);
+            compiler.hooks.done.tap(name, (stats) => {
+                reportCompiledProjectRecords(bridge, stats.compilation.fileDependencies);
+            });
+            compiler.hooks.watchClose.tap(name, () => {
+                // A compiler can watch again with different session options.
+                closeBridge().catch(() => undefined);
+            });
+            compiler.hooks.shutdown.tap(name, () => {
+                // The shared generation outlives this compiler for the next one; the
+                // lease resets it once no compiler has used it for its grace.
+                if (shared === undefined)
+                    resetTtscTransformCache(transformCache);
+                else
+                    shared.lease.release();
+                closeBridge().catch(() => undefined);
+            });
+        },
+        rspack(compiler) {
+            registerTtscSourceMapLoader(compiler);
+            compiler.hooks.done.tap(name, (stats) => {
+                reportCompiledProjectRecords(bridge, stats.compilation.fileDependencies);
+            });
+            compiler.hooks.watchClose.tap(name, () => {
+                // A compiler can watch again with different session options.
+                closeBridge().catch(() => undefined);
+            });
+            compiler.hooks.shutdown.tap(name, () => {
+                // The shared generation outlives this compiler for the next one; the
+                // lease resets it once no compiler has used it for its grace.
+                if (shared === undefined)
+                    resetTtscTransformCache(transformCache);
+                else
+                    shared.lease.release();
+                closeBridge().catch(() => undefined);
+            });
+        },
+        farm: {
+            // Farm offers no per-module opt-out of its persistent cache, so where
+            // no record can be written its cache is turned off (samchon/ttsc#1480).
+            config: (config) => farmPersistentCacheWithoutRecords(config, process.cwd()),
+            configResolved(config) {
+                farmWatching =
+                    config.compilation?.mode === "development" ||
+                        (config.compilation?.watch ?? false) !== false;
+                farmRoot = resolveConfiguredHostRoot(config.root);
+            },
+            // 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);
+                    passStartedAt = bridge?.begin();
+                },
+            },
+        },
+        buildStart() {
+            cachedModules.begin();
+            viteLifecycle.start(this);
+            if (viteLifecycle.command !== undefined) {
+                declareTtscTransformPolling(transformCache, hostDeclaresPolling(process.env, viteLifecycle.usePolling));
+            }
+            // 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
+            // edit can reach the session, nothing invalidates what one touched, and
+            // 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 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 (viteLifecycle.command === "serve" && viteLifecycle.watching) {
+                resetTtscTransformCache(transformCache);
+            }
+            else {
+                beginTtscTransformBuild(transformCache);
+                // Before the host validates a module against its persistent cache:
+                // a project whose state moved while nothing ran is heard through its
+                // record, which only a proof here can move. A watching host's bridge
+                // opens for its first pass and takes every record, so a project the
+                // host restores whole from its cache, with no delivery in this
+                // process, is observed from then on; a later pass of that session
+                // has the bridge observing already, and a one-shot host proves the
+                // records at each start. A host whose cache the adapter answers module
+                // by module, or that keeps none, has nothing for either to cover.
+                const opening = bridge === undefined;
+                if (opening && hostWatching(this)) {
+                    bridge = openHostWatchBridge(hostRoot(), {}, buildHostDeclaresPolling(this.getNativeBuildContext?.()));
+                }
+                passStartedAt = bridge?.begin();
+                if (opening && restoresUnanswered(this)) {
+                    // Below the root, and in the fallback a host that cannot write there
+                    // keeps its records in (samchon/ttsc#1480).
+                    for (const directory of recordDirectories()) {
+                        refreshProjectRecordFiles(directory, bridge);
+                    }
+                }
+            }
+        },
+        transformInclude: includes,
+        async transform(source, id) {
+            const file = stripQuery(id);
+            if (!includes(id)) {
+                return undefined;
+            }
+            // The project-root observer is already live when a Vite serve transform
+            // begins. Its sequence token lets registration prove only inputs that
+            // could have changed during compilation, instead of synchronously
+            // re-reading every input in a large compiler graph.
+            const serveStartedAt = viteLifecycle.command === "serve" && viteLifecycle.watching
+                ? serveInputs.begin()
+                : undefined;
+            const native = this.getNativeBuildContext?.();
+            // The bridge opened with the first pass (`buildStart`); a host that
+            // opened none before its first transform gets it here.
+            const bridgeStartedAt = hostWatching(this)
+                ? (passStartedAt ??= (bridge ??= openHostWatchBridge(hostRoot(), {}, buildHostDeclaresPolling(this.getNativeBuildContext?.()))).begin())
+                : undefined;
+            // A build host takes the project's record, and nothing else, through
+            // the same channel that watches the module itself: Farm relates a watch
+            // file to the module that named it, the webpack and Rspack loader
+            // contexts hold the module-level channel (a compilation-level one
+            // schedules a pass without invalidating the module), and every other
+            // host has one `addWatchFile`.
+            const { addWatchFile, loaderContext } = createBuildWatchFile(this, native, file);
+            // Lifecycle admission needs an actual host declaration, rather than the
+            // ordinary bridge helper's default when no watch capability is reported.
+            const watching = viteLifecycle.command === "serve"
+                ? viteLifecycle.watching
+                : viteLifecycle.command === "build"
+                    ? viteLifecycle.buildWatching
+                    : native?.framework === "webpack" || native?.framework === "rspack"
+                        ? native.compiler.watchMode
+                        : native?.framework === "farm"
+                            ? farmWatching
+                            : this.meta?.watchMode;
+            // What the delivery was handed, for Rollup's cache to be answered by:
+            // the record, or that no cache may serve the module.
+            const handed = { unprovable: false };
+            const result = await transformTtsc(file, source, options, aliases, transformCache, {
+                watching,
+                // A dev server keys each importer on its own inputs through its
+                // module graph; a watcherless one has no invalidation channel and
+                // needs no derivation.
+                ...(createViteServeWatchHooks(viteLifecycle.command, viteLifecycle.watching, serveInputs, file, serveStartedAt) ?? {
+                    project: {
+                        register: (registration) => {
+                            registerProjectRecord({
+                                addWatchFile,
+                                ...(bridge !== undefined && bridgeStartedAt !== undefined
+                                    ? {
+                                        bridge: {
+                                            instance: bridge,
+                                            startedAt: bridgeStartedAt,
+                                        },
+                                    }
+                                    : {}),
+                                registration,
+                            });
+                            if (registration.digest === undefined)
+                                handed.unprovable = true;
+                            else
+                                handed.record = {
+                                    digest: registration.digest,
+                                    file: registration.record,
+                                };
+                        },
+                        toolDirectory: hostToolDirectory(hostRoot()),
+                        ...recordFallback(),
+                        watching: bridge !== undefined,
+                    },
+                }),
+                // 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.
+                ...(answersRollupCache(this) || loaderContext?.cacheable !== undefined
+                    ? {
+                        markVolatile: () => {
+                            handed.unprovable = true;
+                            loaderContext?.cacheable?.(false);
+                        },
+                    }
+                    : {}),
+            });
+            // Unplugin's webpack and Rspack loaders drop the map of a module that
+            // arrived without one, which the first loader's module always does, so
+            // the loader after it hands the map on (samchon/ttsc#1392).
+            if (result?.map !== undefined &&
+                (native?.framework === "webpack" || native?.framework === "rspack") &&
+                native.loaderContext !== undefined) {
+                TTSC_SOURCE_MAP_STASH.set(native.loaderContext, result);
+            }
+            if (!answersRollupCache(this))
+                return result;
+            // The module carries its delivery into Rollup's cache, a module passed
+            // through untransformed too: its project's record still decides whether
+            // a later generation takes it in. Unchanged code with a `null` map is
+            // how a Rollup plugin leaves a module's code and mappings as they are.
+            const delivered = {
+                ...(result ?? { code: source, map: null }),
+                meta: cachedModules.deliver(handed.unprovable
+                    ? null
+                    : {
+                        options: currentDeliveryOptions(),
+                        ...(handed.record === undefined
+                            ? {}
+                            : { record: handed.record }),
+                    }),
+            };
+            return delivered;
+        },
+    };
+};
+/**
+ * The unified `@ttsc/unplugin` instance, carrying one adapter per bundler.
+ *
+ * Built from one factory for Vite, Rollup, Rolldown, webpack, Rspack, esbuild,
+ * and Farm, so every host runs the same transform core. Each host owns its own
+ * lifecycle boundaries: when a delivery pass begins, when a generation is kept
+ * across rebuilds, and when watchers are released. Compiler-only inputs reach
+ * each host's watch channel without entering its runtime module graph.
+ */
+const unplugin = createUnplugin(unpluginFactory);
+
+export { unplugin };
+//# sourceMappingURL=unplugin.mjs.map

package/lib/core/unplugin.mjs.map

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