@ttsc/unplugin 0.20.1 → 0.22.0

package/README.md

@@ -165,6 +165,8 @@ await Bun.build({
 });
 ```
 
+Under `Bun.build`, the adapter yields to the next loader for declarations, `node_modules`, source that `ttsc` leaves unchanged, and entries supplied through `Bun.build({ files })`. In-memory entries remain with Bun because ttsc transforms filesystem-backed project inputs. Bun's runtime `onLoad` contract does not accept an undefined result, so `Bun.plugin()` explicitly passes excluded and unchanged filesystem files through with their original source. `Bun.build` clears the project generation through its `onStart` lifecycle on every build. The runtime API has no corresponding hook, so one setup is treated as one immutable module-loading session: restart the Bun process after changing source, tsconfig, or plugin inputs.
+
 ## Configuration
 
 By default, `@ttsc/unplugin` finds the nearest `tsconfig.json` from the file being transformed and uses that project's plugin settings, including directly installed plugin packages.
@@ -310,7 +312,7 @@ The transform host reports the program's reference graph (the transform envelope
 
 Transform plugins may additionally report, per file, the source files they consulted (the envelope's `dependencies` field); the adapter registers those as watch files too, union semantics. A plugin that declares such a list [complete](https://ttsc.dev/docs/development/concepts/protocol#dependency-completeness) for a file narrows the registration instead: only its own list plus the tsconfig chain, so files the transform never consulted stop invalidating it. Files a plugin declares `volatile` (output depending on non-file inputs such as environment or time) bypass the adapter's transform cache and are marked uncacheable where the bundler exposes that control.
 
-The transform cache itself validates against the same input set: every file under the project root plus the graph-reported inputs outside it (`node_modules` declarations, monorepo sibling sources, out-of-root `extends` ancestry). Hosts that keep one cache for the process lifetime instead of per build (Metro workers, the Turbopack loader, Bun) therefore recompile when any of those inputs changes, not only in-project ones.
+The transform cache uses the same input set: every regular file reached by the non-following project walk plus graph-reported inputs outside that walk (`node_modules` declarations, monorepo sibling sources, files reached through symlinks or Windows junctions, and out-of-root `extends` ancestry). One whole-project compile already contains every module's output. Adapters with a guaranteed build boundary clear the previous generation there, then check only the supplied source on each module's first delivery in that build; a repeated delivery validates the complete snapshots. This avoids one complete project walk per module on an initial build. Bun runtime setup defines one process-scoped loading session. Long-lived hosts without either boundary (Metro workers, the Turbopack loader, and Vite's development server, whose initial `buildStart` spans later HMR edits) validate the complete project and external-input snapshots on every generation hit.
 
 ## Sponsors
 

package/lib/api.js

@@ -6,12 +6,15 @@ var options = require('./core/options.js');
 
 
 
+exports.isTransformTarget = index.isTransformTarget;
 exports.sourceFilePattern = index.sourceFilePattern;
 exports.unplugin = index.default;
+exports.beginTtscTransformBuild = transform.beginTtscTransformBuild;
 exports.collectExternalInputHashes = transform.collectExternalInputHashes;
 exports.collectProjectInputHashes = transform.collectProjectInputHashes;
 exports.createTtscTransformCache = transform.createTtscTransformCache;
 exports.isProjectWalkPath = transform.isProjectWalkPath;
+exports.resetTtscTransformCache = transform.resetTtscTransformCache;
 exports.transformTtsc = transform.transformTtsc;
 exports.resolveOptions = options.resolveOptions;
 //# sourceMappingURL=api.js.map

package/lib/api.js.map

@@ -1 +1 @@
-{"version":3,"file":"api.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"api.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

package/lib/api.mjs

@@ -1,4 +1,4 @@
-export { sourceFilePattern, default as unplugin } from './core/index.mjs';
-export { collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, transformTtsc } from './core/transform.mjs';
+export { isTransformTarget, sourceFilePattern, default as unplugin } from './core/index.mjs';
+export { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, transformTtsc } from './core/transform.mjs';
 export { resolveOptions } from './core/options.mjs';
 //# sourceMappingURL=api.mjs.map

package/lib/bun.d.ts

@@ -29,18 +29,37 @@ export type TtscBunOptions = TtscUnpluginOptions | (() => TtscUnpluginOptions |
 /**
  * Minimal subset of the Bun `BuildConfig` plugin build object.
  *
- * Only the `onLoad` hook is used; other hooks are not needed for a
- * source-to-source transform.
+ * `onLoad` drives the source transform. Bun's bundler also exposes `onStart`,
+ * which is used when available to forward the shared plugin's build lifecycle
+ * and clear its per-build cache. The runtime plugin API omits that hook, so
+ * plugin setup itself starts its one process-scoped module-loading session.
  */
 export interface BunLikeBuild {
+    /**
+     * Build configuration exposed unchanged by Bun's bundler plugin builder.
+     *
+     * Runtime plugin builders do not supply `files`. Bun's bundler accepts an
+     * in-memory file map whose values deliberately remain `unknown` here because
+     * this adapter only needs to preserve ownership, not consume their contents.
+     */
+    config?: {
+        files?: Readonly<Record<string, unknown>>;
+    };
+    /**
+     * Register a callback for the start of a bundler build.
+     *
+     * Optional because `Bun.plugin()` runtime builders do not expose this hook.
+     */
+    onStart?(callback: () => void | Promise<void>): void;
     /**
      * Register a loader callback for files matching `filter`.
      *
-     * The callback receives the absolute file path and must return the
-     * transformed file contents plus the `loader` Bun should apply next. The
-     * `loader` matters most for the runtime path (`Bun.plugin`), where Bun must
-     * be told the returned contents are still TypeScript so it keeps transpiling
-     * them before execution.
+     * The callback receives the file path and must return the transformed file
+     * contents plus the `loader` Bun should apply next. Configured in-memory
+     * files retain relative key spellings; ordinary disk files are normally
+     * absolute. The `loader` matters most for the runtime path (`Bun.plugin`),
+     * where Bun must be told the returned contents are still TypeScript so it
+     * keeps transpiling them before execution.
      */
     onLoad(options: {
         filter: RegExp;
@@ -49,21 +68,28 @@ export interface BunLikeBuild {
     }) => Promise<{
         contents: string;
         loader: BunLoader;
-    }>): void;
+    } | undefined>): void;
 }
 /**
  * Create a ttsc plugin for Bun's bundler AND runtime.
  *
- * Bun does not implement the unplugin protocol, so this adapter instantiates
- * the raw unplugin transform and wires it to Bun's `onLoad` hook manually. The
- * adapter reads each matching file from disk and forwards the content to the
- * ttsc transform; if the transform returns no changes the original source is
- * passed through unchanged.
+ * Bun does not implement the unplugin protocol, so this adapter wires the
+ * shared ttsc transform core to Bun's `onLoad` hook directly. It reads each
+ * included file from disk and forwards the content to the transform. Under
+ * `Bun.build`, excluded files and no-op transforms return `undefined` so the
+ * next loader retains ownership. Entries supplied through `BuildConfig.files`
+ * also stay with Bun's in-memory loader: they are not filesystem project inputs
+ * and reading the same path from disk would either fail or silently replace the
+ * configured contents. The runtime `Bun.plugin()` API rejects an undefined
+ * `onLoad` result, so that path explicitly returns the original source and
+ * loader instead.
  *
  * The same object works for `Bun.build({ plugins: [ttsc()] })` (bundler) and
  * for `Bun.plugin(ttsc())` / a `bunfig.toml` preload (runtime) — see
  * `bun-register`. Every result carries an explicit `loader` so Bun keeps
- * transpiling the emitted TypeScript at runtime; `sourceFilePattern` only
- * matches TypeScript, so the loader is always `ts`/`tsx`.
+ * transpiling the emitted TypeScript at runtime; `bunSourceFilePattern` only
+ * matches TypeScript, so the loader is always `ts`/`tsx`. A runtime plugin
+ * instance is one immutable load session, like Bun's own module cache; restart
+ * the process after changing compiler inputs.
  */
 export default function bun(options?: TtscBunOptions): BunLikePlugin;

package/lib/bun.js

@@ -4,9 +4,18 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var fs = require('node:fs/promises');
 var index = require('./core/index.js');
+var transform = require('./core/transform.js');
+var options = require('./core/options.js');
 
 /**
- * Transform context handed to the raw unplugin transform under Bun.
+ * Bun normally reports filesystem source paths, while plugin-created virtual
+ * ids may contain a NUL sentinel. A virtual id must stay with the plugin that
+ * created it: claiming it here and trying to read it from disk prevents that
+ * plugin's later loader from running.
+ */
+const bunSourceFilePattern = /^[^\x00]*\.[cm]?tsx?$/;
+/**
+ * Transform hooks handed to the shared transform under Bun.
  *
  * The shared transform calls `addWatchFile` once per plugin-reported dependency
  * so type-only inputs can enter a bundler's watch graph. Bun's bundler and
@@ -17,7 +26,7 @@ var index = require('./core/index.js');
  * `this.addWatchFile` `undefined`, so any plugin reporting dependencies threw
  * `TypeError: this.addWatchFile is not a function`.
  */
-const bunTransformContext = {
+const bunTransformHooks = {
     addWatchFile() { },
 };
 /** Resolve {@link TtscBunOptions} to a plain options object (or `undefined`). */
@@ -27,59 +36,106 @@ function resolveBunOptions(options) {
 /**
  * Create a ttsc plugin for Bun's bundler AND runtime.
  *
- * Bun does not implement the unplugin protocol, so this adapter instantiates
- * the raw unplugin transform and wires it to Bun's `onLoad` hook manually. The
- * adapter reads each matching file from disk and forwards the content to the
- * ttsc transform; if the transform returns no changes the original source is
- * passed through unchanged.
+ * Bun does not implement the unplugin protocol, so this adapter wires the
+ * shared ttsc transform core to Bun's `onLoad` hook directly. It reads each
+ * included file from disk and forwards the content to the transform. Under
+ * `Bun.build`, excluded files and no-op transforms return `undefined` so the
+ * next loader retains ownership. Entries supplied through `BuildConfig.files`
+ * also stay with Bun's in-memory loader: they are not filesystem project inputs
+ * and reading the same path from disk would either fail or silently replace the
+ * configured contents. The runtime `Bun.plugin()` API rejects an undefined
+ * `onLoad` result, so that path explicitly returns the original source and
+ * loader instead.
  *
  * The same object works for `Bun.build({ plugins: [ttsc()] })` (bundler) and
  * for `Bun.plugin(ttsc())` / a `bunfig.toml` preload (runtime) — see
  * `bun-register`. Every result carries an explicit `loader` so Bun keeps
- * transpiling the emitted TypeScript at runtime; `sourceFilePattern` only
- * matches TypeScript, so the loader is always `ts`/`tsx`.
+ * transpiling the emitted TypeScript at runtime; `bunSourceFilePattern` only
+ * matches TypeScript, so the loader is always `ts`/`tsx`. A runtime plugin
+ * instance is one immutable load session, like Bun's own module cache; restart
+ * the process after changing compiler inputs.
  */
-function bun(options) {
+function bun(options$1) {
     return {
         name: "ttsc-unplugin",
         setup(build) {
-            // Build the raw transform lazily on first load rather than in `setup`.
-            // Bun runs `setup` synchronously when the plugin is registered, so a
-            // runtime registration (bun-register) that resolves its effective options
-            // through a provider must defer that resolution until after any explicit
-            // `register(options)` call in the same tick. Deferring also keeps a single
-            // transform (and its project cache) shared across every loaded module.
-            let raw;
-            build.onLoad({ filter: index.sourceFilePattern }, async (args) => {
-                raw ??= index.default.raw(resolveBunOptions(options), {});
+            // Resolve options lazily on first load. Runtime registration may call
+            // register(options) immediately after the import-time default
+            // registration; the provider form must observe that last synchronous
+            // update without installing a second shadowing loader.
+            let resolved;
+            const getOptions = () => (resolved ??= options.resolveOptions(resolveBunOptions(options$1)));
+            const cache = transform.createTtscTransformCache();
+            const runtime = build.onStart === undefined;
+            const ownsInMemoryFile = createBunInMemoryFileMatcher(build);
+            // Bun.plugin() has no onStart callback, but one setup invocation belongs
+            // to exactly one runtime process and module-loading session. Mark that
+            // session up front so first delivery of every emitted project module is
+            // constant-time instead of re-reading the whole project. Bun.build()
+            // immediately starts the same initial scope again through onStart and
+            // repeats it for subsequent builds.
+            transform.beginTtscTransformBuild(cache);
+            build.onStart?.(() => transform.beginTtscTransformBuild(cache));
+            build.onLoad({ filter: bunSourceFilePattern }, async (args) => {
+                if (!runtime && ownsInMemoryFile(args.path)) {
+                    return undefined;
+                }
+                if (!index.isTransformTarget(args.path)) {
+                    if (!runtime)
+                        return undefined;
+                    return {
+                        contents: await fs.readFile(args.path, "utf8"),
+                        loader: bunLoaderFor(args.path),
+                    };
+                }
                 const loader = bunLoaderFor(args.path);
                 const source = await fs.readFile(args.path, "utf8");
-                const result = typeof raw.transform === "function"
-                    ? await raw.transform.call(bunTransformContext, source, args.path)
-                    : undefined;
-                // Unpack both shorthand string and object result shapes.
-                if (typeof result === "string") {
-                    return { contents: result, loader };
-                }
-                if (typeof result === "object" &&
-                    result !== null &&
-                    "code" in result &&
-                    typeof result.code === "string") {
+                const result = await transform.transformTtsc(args.path, source, getOptions(), undefined, cache, bunTransformHooks);
+                if (result !== undefined) {
                     return { contents: result.code, loader };
                 }
-                return { contents: source, loader };
+                return runtime ? { contents: source, loader } : undefined;
             });
         },
     };
 }
 /**
- * Pick the Bun loader for a matched file. `sourceFilePattern` is
+ * Pick the Bun loader for a matched file. `bunSourceFilePattern` is
  * `/\.[cm]?tsx?$/`, so a trailing `x` (`.tsx`/`.ctsx`/`.mtsx`) is JSX-flavored
  * TypeScript and everything else (`.ts`/`.cts`/`.mts`) is plain TypeScript.
  */
 function bunLoaderFor(filePath) {
     return /x$/i.test(filePath) ? "tsx" : "ts";
 }
+/**
+ * Create a stable ownership matcher for Bun's `BuildConfig.files` map.
+ *
+ * Bun preserves relative `files` keys in the corresponding `onLoad` path.
+ * Preserve relative versus absolute spelling and dot segments exactly. Windows
+ * normalizes separators and drive-letter case, but not component case. No path
+ * is resolved against cwd, so `process.chdir()` cannot change ownership.
+ */
+function createBunInMemoryFileMatcher(build) {
+    const files = build.config?.files;
+    if (files === undefined)
+        return () => false;
+    const identities = new Set(Object.keys(files).map(bunPathIdentityKey));
+    return (file) => identities.has(bunPathIdentityKey(file));
+}
+/**
+ * Normalize the path forms Bun equates for its in-memory file map.
+ *
+ * Bun normalizes Windows separators and drive-letter case, but preserves path
+ * component case, relative versus absolute spelling, and dot segments. A
+ * filesystem identity key is broader and would suppress real disk transforms.
+ */
+function bunPathIdentityKey(file) {
+    if (process.platform !== "win32")
+        return file;
+    return file
+        .replace(/\\/g, "/")
+        .replace(/^([a-z]):/i, (_match, drive) => `${drive.toLowerCase()}:`);
+}
 
 exports.default = bun;
 //# sourceMappingURL=bun.js.map

package/lib/bun.js.map

@@ -1 +1 @@
-{"version":3,"file":"bun.js","sources":["../src/bun.ts"],"sourcesContent":[null],"names":["sourceFilePattern","unplugin"],"mappings":";;;;;;;AAuCA;;;;;;;;;;;AAWG;AACH,MAAM,mBAAmB,GAAG;AAC1B,IAAA,YAAY,KAAU,CAAC;CACxB;AAED;AACA,SAAS,iBAAiB,CACxB,OAAwB,EAAA;AAExB,IAAA,OAAO,OAAO,OAAO,KAAK,UAAU,GAAG,OAAO,EAAE,GAAG,OAAO;AAC5D;AA0BA;;;;;;;;;;;;;;AAcG;AACW,SAAU,GAAG,CAAC,OAAwB,EAAA;IAClD,OAAO;AACL,QAAA,IAAI,EAAE,eAAe;AACrB,QAAA,KAAK,CAAC,KAAK,EAAA;;;;;;;AAOT,YAAA,IAAI,GAAgD;AACpD,YAAA,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAEA,uBAAiB,EAAE,EAAE,OAAO,IAAI,KAAI;AACzD,gBAAA,GAAG,KAAKC,aAAQ,CAAC,GAAG,CAClB,iBAAiB,CAAC,OAAO,CAAC,EAC1B,EAAyB,CAC1B;gBACD,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;AACtC,gBAAA,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC;AACnD,gBAAA,MAAM,MAAM,GACV,OAAO,GAAG,CAAC,SAAS,KAAK;AACvB,sBAAE,MAAM,GAAG,CAAC,SAAS,CAAC,IAAI,CACtB,mBAA4B,EAC5B,MAAM,EACN,IAAI,CAAC,IAAI;sBAEX,SAAS;;AAEf,gBAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,oBAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE;gBACrC;gBACA,IACE,OAAO,MAAM,KAAK,QAAQ;AAC1B,oBAAA,MAAM,KAAK,IAAI;AACf,oBAAA,MAAM,IAAI,MAAM;AAChB,oBAAA,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,EAC/B;oBACA,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE;gBAC1C;AACA,gBAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE;AACrC,YAAA,CAAC,CAAC;QACJ,CAAC;KACF;AACH;AAEA;;;;AAIG;AACH,SAAS,YAAY,CAAC,QAAgB,EAAA;AACpC,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,KAAK,GAAG,IAAI;AAC5C;;;;"}
+{"version":3,"file":"bun.js","sources":["../src/bun.ts"],"sourcesContent":[null],"names":["options","resolveOptions","createTtscTransformCache","beginTtscTransformBuild","isTransformTarget","transformTtsc"],"mappings":"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"}

package/lib/bun.mjs

@@ -1,8 +1,17 @@
 import fs from 'node:fs/promises';
-import unplugin, { sourceFilePattern } from './core/index.mjs';
+import { isTransformTarget } from './core/index.mjs';
+import { beginTtscTransformBuild, transformTtsc, createTtscTransformCache } from './core/transform.mjs';
+import { resolveOptions } from './core/options.mjs';
 
 /**
- * Transform context handed to the raw unplugin transform under Bun.
+ * Bun normally reports filesystem source paths, while plugin-created virtual
+ * ids may contain a NUL sentinel. A virtual id must stay with the plugin that
+ * created it: claiming it here and trying to read it from disk prevents that
+ * plugin's later loader from running.
+ */
+const bunSourceFilePattern = /^[^\x00]*\.[cm]?tsx?$/;
+/**
+ * Transform hooks handed to the shared transform under Bun.
  *
  * The shared transform calls `addWatchFile` once per plugin-reported dependency
  * so type-only inputs can enter a bundler's watch graph. Bun's bundler and
@@ -13,7 +22,7 @@ import unplugin, { sourceFilePattern } from './core/index.mjs';
  * `this.addWatchFile` `undefined`, so any plugin reporting dependencies threw
  * `TypeError: this.addWatchFile is not a function`.
  */
-const bunTransformContext = {
+const bunTransformHooks = {
     addWatchFile() { },
 };
 /** Resolve {@link TtscBunOptions} to a plain options object (or `undefined`). */
@@ -23,59 +32,106 @@ function resolveBunOptions(options) {
 /**
  * Create a ttsc plugin for Bun's bundler AND runtime.
  *
- * Bun does not implement the unplugin protocol, so this adapter instantiates
- * the raw unplugin transform and wires it to Bun's `onLoad` hook manually. The
- * adapter reads each matching file from disk and forwards the content to the
- * ttsc transform; if the transform returns no changes the original source is
- * passed through unchanged.
+ * Bun does not implement the unplugin protocol, so this adapter wires the
+ * shared ttsc transform core to Bun's `onLoad` hook directly. It reads each
+ * included file from disk and forwards the content to the transform. Under
+ * `Bun.build`, excluded files and no-op transforms return `undefined` so the
+ * next loader retains ownership. Entries supplied through `BuildConfig.files`
+ * also stay with Bun's in-memory loader: they are not filesystem project inputs
+ * and reading the same path from disk would either fail or silently replace the
+ * configured contents. The runtime `Bun.plugin()` API rejects an undefined
+ * `onLoad` result, so that path explicitly returns the original source and
+ * loader instead.
  *
  * The same object works for `Bun.build({ plugins: [ttsc()] })` (bundler) and
  * for `Bun.plugin(ttsc())` / a `bunfig.toml` preload (runtime) — see
  * `bun-register`. Every result carries an explicit `loader` so Bun keeps
- * transpiling the emitted TypeScript at runtime; `sourceFilePattern` only
- * matches TypeScript, so the loader is always `ts`/`tsx`.
+ * transpiling the emitted TypeScript at runtime; `bunSourceFilePattern` only
+ * matches TypeScript, so the loader is always `ts`/`tsx`. A runtime plugin
+ * instance is one immutable load session, like Bun's own module cache; restart
+ * the process after changing compiler inputs.
  */
 function bun(options) {
     return {
         name: "ttsc-unplugin",
         setup(build) {
-            // Build the raw transform lazily on first load rather than in `setup`.
-            // Bun runs `setup` synchronously when the plugin is registered, so a
-            // runtime registration (bun-register) that resolves its effective options
-            // through a provider must defer that resolution until after any explicit
-            // `register(options)` call in the same tick. Deferring also keeps a single
-            // transform (and its project cache) shared across every loaded module.
-            let raw;
-            build.onLoad({ filter: sourceFilePattern }, async (args) => {
-                raw ??= unplugin.raw(resolveBunOptions(options), {});
+            // Resolve options lazily on first load. Runtime registration may call
+            // register(options) immediately after the import-time default
+            // registration; the provider form must observe that last synchronous
+            // update without installing a second shadowing loader.
+            let resolved;
+            const getOptions = () => (resolved ??= resolveOptions(resolveBunOptions(options)));
+            const cache = createTtscTransformCache();
+            const runtime = build.onStart === undefined;
+            const ownsInMemoryFile = createBunInMemoryFileMatcher(build);
+            // Bun.plugin() has no onStart callback, but one setup invocation belongs
+            // to exactly one runtime process and module-loading session. Mark that
+            // session up front so first delivery of every emitted project module is
+            // constant-time instead of re-reading the whole project. Bun.build()
+            // immediately starts the same initial scope again through onStart and
+            // repeats it for subsequent builds.
+            beginTtscTransformBuild(cache);
+            build.onStart?.(() => beginTtscTransformBuild(cache));
+            build.onLoad({ filter: bunSourceFilePattern }, async (args) => {
+                if (!runtime && ownsInMemoryFile(args.path)) {
+                    return undefined;
+                }
+                if (!isTransformTarget(args.path)) {
+                    if (!runtime)
+                        return undefined;
+                    return {
+                        contents: await fs.readFile(args.path, "utf8"),
+                        loader: bunLoaderFor(args.path),
+                    };
+                }
                 const loader = bunLoaderFor(args.path);
                 const source = await fs.readFile(args.path, "utf8");
-                const result = typeof raw.transform === "function"
-                    ? await raw.transform.call(bunTransformContext, source, args.path)
-                    : undefined;
-                // Unpack both shorthand string and object result shapes.
-                if (typeof result === "string") {
-                    return { contents: result, loader };
-                }
-                if (typeof result === "object" &&
-                    result !== null &&
-                    "code" in result &&
-                    typeof result.code === "string") {
+                const result = await transformTtsc(args.path, source, getOptions(), undefined, cache, bunTransformHooks);
+                if (result !== undefined) {
                     return { contents: result.code, loader };
                 }
-                return { contents: source, loader };
+                return runtime ? { contents: source, loader } : undefined;
             });
         },
     };
 }
 /**
- * Pick the Bun loader for a matched file. `sourceFilePattern` is
+ * Pick the Bun loader for a matched file. `bunSourceFilePattern` is
  * `/\.[cm]?tsx?$/`, so a trailing `x` (`.tsx`/`.ctsx`/`.mtsx`) is JSX-flavored
  * TypeScript and everything else (`.ts`/`.cts`/`.mts`) is plain TypeScript.
  */
 function bunLoaderFor(filePath) {
     return /x$/i.test(filePath) ? "tsx" : "ts";
 }
+/**
+ * Create a stable ownership matcher for Bun's `BuildConfig.files` map.
+ *
+ * Bun preserves relative `files` keys in the corresponding `onLoad` path.
+ * Preserve relative versus absolute spelling and dot segments exactly. Windows
+ * normalizes separators and drive-letter case, but not component case. No path
+ * is resolved against cwd, so `process.chdir()` cannot change ownership.
+ */
+function createBunInMemoryFileMatcher(build) {
+    const files = build.config?.files;
+    if (files === undefined)
+        return () => false;
+    const identities = new Set(Object.keys(files).map(bunPathIdentityKey));
+    return (file) => identities.has(bunPathIdentityKey(file));
+}
+/**
+ * Normalize the path forms Bun equates for its in-memory file map.
+ *
+ * Bun normalizes Windows separators and drive-letter case, but preserves path
+ * component case, relative versus absolute spelling, and dot segments. A
+ * filesystem identity key is broader and would suppress real disk transforms.
+ */
+function bunPathIdentityKey(file) {
+    if (process.platform !== "win32")
+        return file;
+    return file
+        .replace(/\\/g, "/")
+        .replace(/^([a-z]):/i, (_match, drive) => `${drive.toLowerCase()}:`);
+}
 
 export { bun as default };
 //# sourceMappingURL=bun.mjs.map

package/lib/bun.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"bun.mjs","sources":["../src/bun.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAuCA;;;;;;;;;;;AAWG;AACH,MAAM,mBAAmB,GAAG;AAC1B,IAAA,YAAY,KAAU,CAAC;CACxB;AAED;AACA,SAAS,iBAAiB,CACxB,OAAwB,EAAA;AAExB,IAAA,OAAO,OAAO,OAAO,KAAK,UAAU,GAAG,OAAO,EAAE,GAAG,OAAO;AAC5D;AA0BA;;;;;;;;;;;;;;AAcG;AACW,SAAU,GAAG,CAAC,OAAwB,EAAA;IAClD,OAAO;AACL,QAAA,IAAI,EAAE,eAAe;AACrB,QAAA,KAAK,CAAC,KAAK,EAAA;;;;;;;AAOT,YAAA,IAAI,GAAgD;AACpD,YAAA,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,EAAE,OAAO,IAAI,KAAI;AACzD,gBAAA,GAAG,KAAK,QAAQ,CAAC,GAAG,CAClB,iBAAiB,CAAC,OAAO,CAAC,EAC1B,EAAyB,CAC1B;gBACD,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;AACtC,gBAAA,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC;AACnD,gBAAA,MAAM,MAAM,GACV,OAAO,GAAG,CAAC,SAAS,KAAK;AACvB,sBAAE,MAAM,GAAG,CAAC,SAAS,CAAC,IAAI,CACtB,mBAA4B,EAC5B,MAAM,EACN,IAAI,CAAC,IAAI;sBAEX,SAAS;;AAEf,gBAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,oBAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE;gBACrC;gBACA,IACE,OAAO,MAAM,KAAK,QAAQ;AAC1B,oBAAA,MAAM,KAAK,IAAI;AACf,oBAAA,MAAM,IAAI,MAAM;AAChB,oBAAA,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,EAC/B;oBACA,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE;gBAC1C;AACA,gBAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE;AACrC,YAAA,CAAC,CAAC;QACJ,CAAC;KACF;AACH;AAEA;;;;AAIG;AACH,SAAS,YAAY,CAAC,QAAgB,EAAA;AACpC,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,KAAK,GAAG,IAAI;AAC5C;;;;"}
+{"version":3,"file":"bun.mjs","sources":["../src/bun.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/core/index.d.ts

@@ -1,7 +1,7 @@
 import type { UnpluginInstance } from "unplugin";
 import type { TtscUnpluginOptions } from "./options";
 import { resolveOptions } from "./options";
-import { collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, transformTtsc } from "./transform";
+import { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, transformTtsc } from "./transform";
 /**
  * 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
@@ -11,5 +11,13 @@ export declare const sourceFilePattern: RegExp;
 declare const unplugin: UnpluginInstance<TtscUnpluginOptions | undefined, false>;
 export type { TtscUnpluginCompilerOptionsJson, TtscUnpluginOptions, } from "./options";
 export type { TtscTransformHooks } from "./transform";
-export { collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resolveOptions, transformTtsc, unplugin, };
+export { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, resolveOptions, transformTtsc, unplugin, };
 export default unplugin;
+/**
+ * Returns `true` when the module id refers to a real TypeScript/JavaScript
+ * source file that should be processed by the ttsc transform.
+ *
+ * Excluded ids: virtual modules (NUL prefix), `.d.ts` declaration files, and
+ * anything inside `node_modules`.
+ */
+export declare function isTransformTarget(id: string): boolean;

package/lib/core/index.js

@@ -29,9 +29,9 @@ const virtualModulePattern = /\0/;
  *
  * 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. The cache
- * is cleared on every `buildStart` to avoid stale results across watch-mode
- * rebuilds.
+ * that path aliases are forwarded to the generated tsconfig overlay. Real build
+ * lifecycles use a per-build cache; Vite's development server keeps persistent
+ * validation because its one `buildStart` spans later HMR edits.
  */
 const unpluginFactory = (rawOptions = {}) => {
     const options$1 = options.resolveOptions(rawOptions);
@@ -67,7 +67,12 @@ const unpluginFactory = (rawOptions = {}) => {
             },
         },
         buildStart() {
-            transformCache.clear();
+            if (viteCommand === "serve") {
+                transform.resetTtscTransformCache(transformCache);
+            }
+            else {
+                transform.beginTtscTransformBuild(transformCache);
+            }
         },
         transformInclude(id) {
             const file = transform.stripQuery(id);
@@ -128,12 +133,15 @@ function isTransformTarget(id) {
 }
 
 exports.resolveOptions = options.resolveOptions;
+exports.beginTtscTransformBuild = transform.beginTtscTransformBuild;
 exports.collectExternalInputHashes = transform.collectExternalInputHashes;
 exports.collectProjectInputHashes = transform.collectProjectInputHashes;
 exports.createTtscTransformCache = transform.createTtscTransformCache;
 exports.isProjectWalkPath = transform.isProjectWalkPath;
+exports.resetTtscTransformCache = transform.resetTtscTransformCache;
 exports.transformTtsc = transform.transformTtsc;
 exports.default = unplugin;
+exports.isTransformTarget = isTransformTarget;
 exports.sourceFilePattern = sourceFilePattern;
 exports.unplugin = unplugin;
 //# sourceMappingURL=index.js.map

package/lib/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":["options","resolveOptions","createTtscTransformCache","createViteServeMissingInputWatch","stripQuery","transformTtsc","createUnplugin","isDeclarationFile"],"mappings":";;;;;;;;;;;AAkBA,MAAM,IAAI,GAAG,eAAe;AAC5B;;;;AAIG;AACI,MAAM,iBAAiB,GAAG;AACjC;AACA,MAAM,kBAAkB,GAAG,oCAAoC;AAC/D;;;AAGG;AACH,MAAM,oBAAoB,GAAG,IAAI;AAEjC;;;;;;;;;AASG;AACH,MAAM,eAAe,GAGjB,CAAC,UAAU,GAAG,EAAE,KAAI;AACtB,IAAA,MAAMA,SAAO,GAAGC,sBAAc,CAAC,UAAU,CAAC;AAC1C,IAAA,MAAM,cAAc,GAAGC,kCAAwB,EAAE;AACjD,IAAA,MAAM,aAAa,GAAGC,0CAAgC,EAAE;AACxD,IAAA,IAAI,OAAgB;AACpB,IAAA,IAAI,WAA+B;IAEnC,OAAO;QACL,IAAI;AACJ,QAAA,OAAO,EAAE,KAAK;AAEd,QAAA,IAAI,EAAE;AACJ,YAAA,cAAc,CAAC,MAAM,EAAA;AACnB,gBAAA,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK;;;;;AAK9B,gBAAA,WAAW,GAAG,MAAM,CAAC,OAAO;YAC9B,CAAC;;;;;;;AAOD,YAAA,eAAe,CAAC,MAAM,EAAA;AACpB,gBAAA,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC;YAC9B,CAAC;;;YAGD,QAAQ,GAAA;gBACN,aAAa,CAAC,OAAO,EAAE;YACzB,CAAC;AACF,SAAA;QAED,UAAU,GAAA;YACR,cAAc,CAAC,KAAK,EAAE;QACxB,CAAC;AAED,QAAA,gBAAgB,CAAC,EAAE,EAAA;AACjB,YAAA,MAAM,IAAI,GAAGC,oBAAU,CAAC,EAAE,CAAC;AAC3B,YAAA,OAAO,iBAAiB,CAAC,IAAI,CAAC;QAChC,CAAC;AAED,QAAA,MAAM,SAAS,CAAC,MAAM,EAAE,EAAE,EAAA;AACxB,YAAA,MAAM,IAAI,GAAGA,oBAAU,CAAC,EAAE,CAAC;AAC3B,YAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;AAC5B,gBAAA,OAAO,SAAS;YAClB;YACA,OAAOC,uBAAa,CAAC,IAAI,EAAE,MAAM,EAAEL,SAAO,EAAE,OAAO,EAAE,cAAc,EAAE;;;;;;;;;;;AAWnE,gBAAA,YAAY,EAAE,CAAC,OAAO,KAAI;oBACxB,IACE,WAAW,KAAK,OAAO;wBACvB,aAAa,CAAC,OAAO,EAAE;AACvB,wBAAA,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EACvB;AACA,wBAAA,aAAa,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;wBAChD;oBACF;AACA,oBAAA,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;gBAC5B,CAAC;;;;gBAID,YAAY,EAAE,MAAK;AACjB,oBAAA,MAAM,MAAM,GAAG,IAAI,CAAC,qBAAqB,IAAI;AAC7C,oBAAA,IACE,MAAM,EAAE,SAAS,KAAK,SAAS;AAC/B,wBAAA,MAAM,EAAE,SAAS,KAAK,QAAQ,EAC9B;wBACA,MAAM,CAAC,aAAa,EAAE,SAAS,GAAG,KAAK,CAAC;oBAC1C;gBACF,CAAC;AACF,aAAA,CAAC;QACJ,CAAC;KACF;AACH,CAAC;AAED,MAAM,QAAQ,GACZM,yBAAc,CAAC,eAAe;AAmBhC;;;;;;AAMG;AACH,SAAS,iBAAiB,CAAC,EAAU,EAAA;AACnC,IAAA,QACE,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1B,QAAA,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9B,CAACC,2BAAiB,CAAC,EAAE,CAAC;AACtB,QAAA,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC;AAEhC;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":["options","resolveOptions","createTtscTransformCache","createViteServeMissingInputWatch","resetTtscTransformCache","beginTtscTransformBuild","stripQuery","transformTtsc","createUnplugin","isDeclarationFile"],"mappings":"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"}

package/lib/core/index.mjs

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createUnplugin } from 'unplugin';
 import { resolveOptions } from './options.mjs';
-import { stripQuery, transformTtsc, isDeclarationFile, createTtscTransformCache } from './transform.mjs';
+import { stripQuery, transformTtsc, beginTtscTransformBuild, isDeclarationFile, resetTtscTransformCache, createTtscTransformCache } from './transform.mjs';
 export { collectExternalInputHashes, collectProjectInputHashes, isProjectWalkPath } from './transform.mjs';
 import { createViteServeMissingInputWatch } from './viteServe.mjs';
 
@@ -26,9 +26,9 @@ const virtualModulePattern = /\0/;
  *
  * 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. The cache
- * is cleared on every `buildStart` to avoid stale results across watch-mode
- * rebuilds.
+ * that path aliases are forwarded to the generated tsconfig overlay. Real build
+ * lifecycles use a per-build cache; Vite's development server keeps persistent
+ * validation because its one `buildStart` spans later HMR edits.
  */
 const unpluginFactory = (rawOptions = {}) => {
     const options = resolveOptions(rawOptions);
@@ -64,7 +64,12 @@ const unpluginFactory = (rawOptions = {}) => {
             },
         },
         buildStart() {
-            transformCache.clear();
+            if (viteCommand === "serve") {
+                resetTtscTransformCache(transformCache);
+            }
+            else {
+                beginTtscTransformBuild(transformCache);
+            }
         },
         transformInclude(id) {
             const file = stripQuery(id);
@@ -124,5 +129,5 @@ function isTransformTarget(id) {
         !nodeModulesPattern.test(id));
 }
 
-export { createTtscTransformCache, unplugin as default, resolveOptions, sourceFilePattern, transformTtsc, unplugin };
+export { beginTtscTransformBuild, createTtscTransformCache, unplugin as default, isTransformTarget, resetTtscTransformCache, resolveOptions, sourceFilePattern, transformTtsc, unplugin };
 //# sourceMappingURL=index.mjs.map