@ttsc/unplugin 0.28.1 → 0.28.3

package/README.md

@@ -312,7 +312,9 @@ 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. The JavaScript host also reports the descriptor's loaded CommonJS graph, every package manifest inspected by auto-discovery, and plugin-declared `hostInputs`. First-party plugins use that last field for implicit config discovery and evaluated config dependencies. These remain universal without turning arbitrary project assets into configuration. 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 snapshots 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 from a complete generation in that build. An incomplete generation never takes that shortcut. Later deliveries of a graph-bearing generation validate that file's reference closure, globals, configs, resolution candidates, plugin dependencies, and exact host inputs. Every input a generation has already proven carries the nanosecond metadata signature captured around the read that proved it, so a later delivery that finds the signature unchanged reuses that proof instead of re-reading the bytes; any signature change falls back to the full content comparison. A signature is recorded only for a read nothing raced, only for an input whose recorded state came from bytes that were read, since the metadata of a path nothing could read holds still while the bytes behind it appear, and only once the observed filesystem's own clock has provably left the tick that minted the input's modification stamp. A filesystem stamps writes once per clock tick, so a same-length rewrite landing inside the recorded stamp's tick would leave the signature unchanged; until some stamp the same filesystem minted later separates that tick, the content comparison keeps running, and the signature is re-earned the moment it can be. The reference instants come from the filesystem itself, never from the process clock: every stamp the adapter observes raises a floor kept per reporting device, and the adapter also stamps a probe in its own scratch directory (the way git separates racily-clean index entries with the index file's own timestamp) to cover a tree whose files were all written inside one tick. The probe counts only when the scratch volume is the inputs' volume, so on a split-volume layout the observed stamps carry the rule alone; an input they cannot separate is re-read rather than trusted. Both sides of every comparison are therefore stamps of equal granularity minted by one clock, so a filesystem clock running behind the host changes nothing. The floor is a maximum over stamps it merely observed, so what defeats it is a stamp that was set into the future rather than minted, such as a stamp-preserving extraction or copy from a machine whose clock ran ahead. A restored past stamp is harmless, since it never raises the floor. A clock that jumps backwards strands the floor above the present the same way, which is a different hazard from a clock running at a constant offset: an offset moves both stamps being compared and changes nothing, while a jump moves only the present. No stamp-based freshness proof survives either one. Sibling modules therefore share one proof of the closure and the globals rather than repeating it per module. Generation-scoped directory notifications detect new, removed, or renamed project inputs without repeating a directory-stat pass per module; Windows isolates those notifications so deletion of a watched temporary tree cannot crash the host. An absent resolution candidate is the one input a metadata signature cannot stand for, since a path that is not there has no metadata to compare. The generation therefore registers those names with a watcher of their own, along with the directory components of the spelling that lead to them, down to the project's own root, and a delivery reads the notification instead of re-probing each candidate. That makes the notification the sole positive evidence for this one input class, which is why the registration reaches past the candidate itself: a watcher opened on a path that traverses a link follows it, so retargeting the link would otherwise move the answer without disturbing what is watched, and a package link inside `node_modules` is exactly that. It stops at the project root, and a candidate whose spelling leaves the project subtree before reaching it is not claimed at all: above that line the components are the machine's own layout rather than the project's, which nobody retargets and which changes for reasons no generation should hear about. It listens for renames alone, since every event that can change a candidate's answer is one — the file appearing, a component being created, replaced or retargeted — while the directories carrying them have their attributes moved by anything written below. A candidate whose watch could not be opened, whose watcher has since failed, or that belongs to a set spanning more directories than the generation will watch, is probed exactly as before: a host that runs out of watch descriptors would fail the tracker outright, which costs every delivery a whole-project comparison rather than one probe. What none of that covers is a filesystem that accepts a watch and then reports nothing, which some network mounts do; that is the same assumption the project-membership proof beside it already rests on, though a wider one here: the project walk skips `node_modules`, so a candidate under it was never covered by that proof and kept a notification-independent probe until now. A project on such a mount should be treated as one where notifications do not work rather than one where they merely have not fired. The barrier that lets a synchronous edit reach those watchers before a delivery reads their verdict is the watcher's own acknowledgement rather than a fixed wait: an in-process watcher answers on the next turn of the loop its callbacks are queued on, and the Windows broker answers by an ordered round-trip, so a delivery waits for the crossing instead of guessing at it. The project is snapshotted before and after compilation, while every graph member carries the compiler filesystem's content and physical-identity proof; only a complete generation that still matches both may authorize narrow reuse. This also rejects an in-project or external A→B→A change whose restored post-compile bytes would otherwise hide the transient state used by the compiler. `dependenciesComplete` narrows file inputs by the same contract as watch registration, and a project reaches it without a type-driven plugin: ttsc's own transform lanes print syntactically, so the host declares every file complete when no plugin can contribute to it, and the first-party `@ttsc/banner` and `@ttsc/strip` declare their own contribution the same way. Such a delivery validates the universal inputs and the file itself instead of its reference closure. A narrowed file's diagnostics narrow with it: an edit to a file the declaration dropped no longer re-runs the compile, so a type error introduced there surfaces at the next compile the build runs for another reason rather than at the edit. Run the compiler's own check beside the bundler when you want it at the edit. Envelopes without a graph, and generations whose watchers could not be opened or have since failed, retain complete-snapshot validation: losing a notification is the absence of a membership proof rather than evidence of a change, so such a generation keeps validating against its own recorded state (the directory snapshot, the input hashes, and the universal descriptor inputs whose every rejection is evidence of a change rather than an inability to prove one) instead of being discarded. A reported membership event is evidence, and still replaces the generation. Only an unstable or incomplete generation is refused outright. Bun runtime setup defines one process-scoped loading session. A dev server started without a watcher takes the build-scoped lifecycle instead of persistent validation. `server.watch: null` leaves the session no channel through which a file change could ever reach it, so what per-delivery validation buys there is incoherence rather than freshness: modules delivered before an edit and after it would come from two different compilations of one program. Each module's first delivery in such a session is therefore settled against the generation the session started from, exactly as under a build, while a module the session already delivered keeps revalidating on its next request. Long-lived hosts without either boundary (Metro workers, the Turbopack loader, and a watching Vite development server, whose initial `buildStart` spans later HMR edits) apply the file-specific validation on every generation hit.
+The transform cache snapshots 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 from a complete generation in that build. An incomplete generation never takes that shortcut. Later deliveries of a graph-bearing generation validate that file's reference closure, globals, configs, resolution candidates, plugin dependencies, and exact host inputs. Every input a generation has already proven carries the nanosecond metadata signature captured around the read that proved it, so a later delivery that finds the signature unchanged reuses that proof instead of re-reading the bytes; any signature change falls back to the full content comparison. A signature is recorded only for a read nothing raced, only for an input whose recorded state came from bytes that were read, since the metadata of a path nothing could read holds still while the bytes behind it appear, and only once the observed filesystem's own clock has provably left the tick that minted the input's modification stamp. A filesystem stamps writes once per clock tick, so a same-length rewrite landing inside the recorded stamp's tick would leave the signature unchanged; until some stamp the same filesystem minted later separates that tick, the content comparison keeps running, and the signature is re-earned the moment it can be. The reference instants come from the filesystem itself, never from the process clock: every stamp the adapter observes raises a floor kept per reporting device, and the adapter also stamps a probe in its own scratch directory (the way git separates racily-clean index entries with the index file's own timestamp) to cover a tree whose files were all written inside one tick. The probe counts only when the scratch volume is the inputs' volume, so on a split-volume layout the observed stamps carry the rule alone; an input they cannot separate is re-read rather than trusted. Both sides of every comparison are therefore stamps of equal granularity minted by one clock, so a filesystem clock running behind the host changes nothing. The floor is a maximum over stamps it merely observed, so what defeats it is a stamp that was set into the future rather than minted, such as a stamp-preserving extraction or copy from a machine whose clock ran ahead. A restored past stamp is harmless, since it never raises the floor. A clock that jumps backwards strands the floor above the present the same way, which is a different hazard from a clock running at a constant offset: an offset moves both stamps being compared and changes nothing, while a jump moves only the present. No stamp-based freshness proof survives either one. Sibling modules therefore share one proof of the closure and the globals rather than repeating it per module. Generation-scoped directory notifications detect new, removed, or renamed project inputs without repeating a directory-stat pass per module; Windows isolates those notifications so deletion of a watched temporary tree cannot crash the host. An absent resolution candidate is the one input a metadata signature cannot stand for, since a path that is not there has no metadata to compare. The generation therefore registers those names with a watcher of their own, along with the directory components of the spelling that lead to them, down to the project's own root, and a delivery reads the notification instead of re-probing each candidate. That makes the notification the sole positive evidence for this one input class, which is why the registration reaches past the candidate itself: a watcher opened on a path that traverses a link follows it, so retargeting the link would otherwise move the answer without disturbing what is watched, and a package link inside `node_modules` is exactly that. It stops at the project root, and a candidate whose spelling leaves the project subtree before reaching it is not claimed at all: above that line the components are the machine's own layout rather than the project's, which nobody retargets and which changes for reasons no generation should hear about. It listens for renames alone, since every event that can change a candidate's answer is one — the file appearing, a component being created, replaced or retargeted — while the directories carrying them have their attributes moved by anything written below. A candidate whose watch could not be opened, whose watcher has since failed, or that belongs to a set spanning more directories than the generation will watch, is probed exactly as before: a host that runs out of watch descriptors would fail the tracker outright, which costs every delivery a whole-project comparison rather than one probe. What none of that covers is a filesystem that accepts a watch and then reports nothing, which some network mounts do; that is the same assumption the project-membership proof beside it already rests on, though a wider one here: the project walk skips `node_modules`, so a candidate under it was never covered by that proof and kept a notification-independent probe until now. A project on such a mount should be treated as one where notifications do not work rather than one where they merely have not fired. The barrier that lets a synchronous edit reach those watchers before a delivery reads their verdict is the watcher's own acknowledgement rather than a fixed wait: an in-process watcher answers on the next turn of the loop its callbacks are queued on, and the Windows broker answers by an ordered round-trip, so a delivery waits for the crossing instead of guessing at it. The project is snapshotted before and after compilation, while every graph member carries the compiler filesystem's content and physical-identity proof; only a complete generation that still matches both may authorize narrow reuse. This also rejects an in-project or external A→B→A change whose restored post-compile bytes would otherwise hide the transient state used by the compiler. `dependenciesComplete` narrows file inputs by the same contract as watch registration, and a project reaches it without a type-driven plugin: ttsc's own transform lanes print syntactically, so the host declares every file complete when no plugin can contribute to it, and the first-party `@ttsc/banner` and `@ttsc/strip` declare their own contribution the same way. Such a delivery validates the universal inputs and the file itself instead of its reference closure. A narrowed file's diagnostics narrow with it: an edit to a file the declaration dropped no longer re-runs the compile, so a type error introduced there surfaces at the next compile the build runs for another reason rather than at the edit. Run the compiler's own check beside the bundler when you want it at the edit. Envelopes without a graph, and generations whose watchers could not be opened or have since failed, retain complete-snapshot validation: losing a notification is the absence of a membership proof rather than evidence of a change, so such a generation keeps validating against its own recorded state (the directory snapshot, the input hashes, and the universal descriptor inputs whose every rejection is evidence of a change rather than an inability to prove one) instead of being discarded. A reported membership event is evidence, and still replaces the generation. For a caching host, an unstable or incomplete attempt is never published: all waiters share one bounded stabilization retry inside the same generation. A stable retry alone resolves and is reused; a second unprovable attempt rejects the shared generation with bounded path-and-proof witnesses. That terminal verdict stays cached while its project, external, and host-input fingerprints remain unchanged, so later request waves pay only the confirmation probes and the compile count is independent of module count. An input change or an explicit cache lifecycle reset permits a new generation. One-shot calls without a cache retain their single compile. Bun runtime setup defines one process-scoped loading session. A dev server started without a watcher takes the build-scoped lifecycle instead of persistent validation. `server.watch: null` leaves the session no channel through which a file change could ever reach it, so what per-delivery validation buys there is incoherence rather than freshness: modules delivered before an edit and after it would come from two different compilations of one program. Each module's first delivery in such a session is therefore settled against the generation the session started from, exactly as under a build, while a module the session already delivered keeps revalidating on its next request. Long-lived hosts without either boundary (Metro workers, the Turbopack loader, and a watching Vite development server, whose initial `buildStart` spans later HMR edits) apply the file-specific validation on every generation hit.
+
+Transform source outputs outside the project walk are kept in that external snapshot too. A non-declaration output is reusable only when the graph carries its compiler-time content and physical-identity proof; a post-compile disk read cannot prove which bytes produced the output. Its source hash then lets sibling module requests validate the same generation without adding arbitrary output keys to the project-file universe.
 
 ## Sponsors
 

package/lib/api.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Public API surface for `@ttsc/unplugin`.
+ *
+ * Re-exports everything from `core/index` so consumers can access the unified
+ * `unplugin` instance, the transform helpers, and the option types from the
+ * `@ttsc/unplugin/api` entry point without importing directly from `core/`.
+ */
+export * from "./core/index.cjs";

package/lib/api.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Public API surface for `@ttsc/unplugin`.
+ *
+ * Re-exports everything from `core/index` so consumers can access the unified
+ * `unplugin` instance, the transform helpers, and the option types from the
+ * `@ttsc/unplugin/api` entry point without importing directly from `core/`.
+ */
+export * from "./core/index.mjs";

package/lib/bun-register.d.cts

@@ -0,0 +1,25 @@
+import type { TtscUnpluginOptions } from "./core/options.cjs";
+/**
+ * Register the ttsc transform as a Bun **runtime** plugin.
+ *
+ * The other `@ttsc/unplugin/*` adapters cover bundlers (`Bun.build`, Vite,
+ * Webpack, …). This entry is the runtime counterpart: loading it registers the
+ * same transform on Bun's module loader, so `bun run` / `bun test` apply ttsc
+ * plugins (e.g. typia's `typia/lib/transform`) as files are imported, with no
+ * bundling step. Wire it up once via a `bunfig.toml` preload entry — `preload =
+ * ["@ttsc/unplugin/bun-register"]` — or imperatively with `import
+ * "@ttsc/unplugin/bun-register"`. Options are read from the nearest
+ * `tsconfig.json`, identical to the bundler adapters.
+ *
+ * Registration is idempotent: the first call (implicit on import, or explicit)
+ * registers the one loader with Bun; later calls only update the effective
+ * options, so accessing the explicit API cannot install a second default loader
+ * that shadows the caller's configuration. Repeated explicit calls are
+ * last-write-wins for the effective options.
+ *
+ * @throws When called explicitly off the Bun runtime (`globalThis.Bun.plugin`
+ *   is unavailable). The auto-registration below stays silent off Bun so the
+ *   module is harmless to import from Node (tests, tooling).
+ */
+export declare function register(options?: TtscUnpluginOptions): void;
+export default register;

package/lib/bun-register.d.mts

@@ -0,0 +1,25 @@
+import type { TtscUnpluginOptions } from "./core/options.mjs";
+/**
+ * Register the ttsc transform as a Bun **runtime** plugin.
+ *
+ * The other `@ttsc/unplugin/*` adapters cover bundlers (`Bun.build`, Vite,
+ * Webpack, …). This entry is the runtime counterpart: loading it registers the
+ * same transform on Bun's module loader, so `bun run` / `bun test` apply ttsc
+ * plugins (e.g. typia's `typia/lib/transform`) as files are imported, with no
+ * bundling step. Wire it up once via a `bunfig.toml` preload entry — `preload =
+ * ["@ttsc/unplugin/bun-register"]` — or imperatively with `import
+ * "@ttsc/unplugin/bun-register"`. Options are read from the nearest
+ * `tsconfig.json`, identical to the bundler adapters.
+ *
+ * Registration is idempotent: the first call (implicit on import, or explicit)
+ * registers the one loader with Bun; later calls only update the effective
+ * options, so accessing the explicit API cannot install a second default loader
+ * that shadows the caller's configuration. Repeated explicit calls are
+ * last-write-wins for the effective options.
+ *
+ * @throws When called explicitly off the Bun runtime (`globalThis.Bun.plugin`
+ *   is unavailable). The auto-registration below stays silent off Bun so the
+ *   module is harmless to import from Node (tests, tooling).
+ */
+export declare function register(options?: TtscUnpluginOptions): void;
+export default register;

package/lib/bun.d.cts

@@ -0,0 +1,95 @@
+import type { TtscUnpluginOptions } from "./core/options.cjs";
+/**
+ * Minimal subset of the Bun plugin API consumed by this adapter.
+ *
+ * Bun does not yet ship TypeScript types for its bundler plugin interface, so
+ * we define the subset we need here. This keeps the adapter free of a Bun
+ * runtime dependency while remaining type-safe.
+ */
+export interface BunLikePlugin {
+    /** Plugin identifier shown in Bun bundler output. */
+    name: string;
+    /** Called by Bun when the plugin is registered. */
+    setup(build: BunLikeBuild): void | Promise<void>;
+}
+/** Bun loader identifiers this adapter can emit (only TypeScript is matched). */
+export type BunLoader = "ts" | "tsx";
+/**
+ * Options accepted by {@link bun}, either resolved eagerly or supplied through a
+ * provider evaluated lazily on the first `onLoad` call.
+ *
+ * The provider form exists for the runtime registration path (`bun-register`),
+ * where a single Bun plugin is registered on import but its effective options
+ * may be overridden by an explicit `register(options)` call made in the same
+ * synchronous tick. Resolving through the provider on first load, rather than
+ * at registration, lets that later call win without Bun ever seeing a second
+ * shadowing loader.
+ */
+export type TtscBunOptions = TtscUnpluginOptions | (() => TtscUnpluginOptions | undefined);
+/**
+ * Minimal subset of the Bun `BuildConfig` plugin build object.
+ *
+ * `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 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;
+    }, loader: (args: {
+        path: string;
+    }) => Promise<{
+        contents: string;
+        loader: BunLoader;
+    } | undefined>): void;
+}
+/**
+ * Create a ttsc plugin for Bun's bundler AND runtime.
+ *
+ * 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; `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.d.mts

@@ -0,0 +1,95 @@
+import type { TtscUnpluginOptions } from "./core/options.mjs";
+/**
+ * Minimal subset of the Bun plugin API consumed by this adapter.
+ *
+ * Bun does not yet ship TypeScript types for its bundler plugin interface, so
+ * we define the subset we need here. This keeps the adapter free of a Bun
+ * runtime dependency while remaining type-safe.
+ */
+export interface BunLikePlugin {
+    /** Plugin identifier shown in Bun bundler output. */
+    name: string;
+    /** Called by Bun when the plugin is registered. */
+    setup(build: BunLikeBuild): void | Promise<void>;
+}
+/** Bun loader identifiers this adapter can emit (only TypeScript is matched). */
+export type BunLoader = "ts" | "tsx";
+/**
+ * Options accepted by {@link bun}, either resolved eagerly or supplied through a
+ * provider evaluated lazily on the first `onLoad` call.
+ *
+ * The provider form exists for the runtime registration path (`bun-register`),
+ * where a single Bun plugin is registered on import but its effective options
+ * may be overridden by an explicit `register(options)` call made in the same
+ * synchronous tick. Resolving through the provider on first load, rather than
+ * at registration, lets that later call win without Bun ever seeing a second
+ * shadowing loader.
+ */
+export type TtscBunOptions = TtscUnpluginOptions | (() => TtscUnpluginOptions | undefined);
+/**
+ * Minimal subset of the Bun `BuildConfig` plugin build object.
+ *
+ * `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 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;
+    }, loader: (args: {
+        path: string;
+    }) => Promise<{
+        contents: string;
+        loader: BunLoader;
+    } | undefined>): void;
+}
+/**
+ * Create a ttsc plugin for Bun's bundler AND runtime.
+ *
+ * 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; `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/core/index.d.cts

@@ -0,0 +1,23 @@
+import type { UnpluginInstance } from "unplugin";
+import type { TtscUnpluginOptions } from "./options.cjs";
+import { resolveOptions } from "./options.cjs";
+import { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, transformTtsc } from "./transform.cjs";
+/**
+ * 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.
+ */
+export declare const sourceFilePattern: RegExp;
+declare const unplugin: UnpluginInstance<TtscUnpluginOptions | undefined, false>;
+export type { TtscUnpluginCompilerOptionsJson, TtscUnpluginOptions, } from "./options.cjs";
+export type { TtscTransformFilesystemOperations, TtscTransformHooks, TtscWatchInputEvidence, } from "./transform.cjs";
+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.d.mts

@@ -0,0 +1,23 @@
+import type { UnpluginInstance } from "unplugin";
+import type { TtscUnpluginOptions } from "./options.mjs";
+import { resolveOptions } from "./options.mjs";
+import { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, transformTtsc } from "./transform.mjs";
+/**
+ * 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.
+ */
+export declare const sourceFilePattern: RegExp;
+declare const unplugin: UnpluginInstance<TtscUnpluginOptions | undefined, false>;
+export type { TtscUnpluginCompilerOptionsJson, TtscUnpluginOptions, } from "./options.mjs";
+export type { TtscTransformFilesystemOperations, TtscTransformHooks, TtscWatchInputEvidence, } from "./transform.mjs";
+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

@@ -42,6 +42,12 @@ const unpluginFactory = (rawOptions = {}) => {
     let aliases;
     let viteCommand;
     let viteWatching = true;
+    // 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.
+    const viteBuildOwners = new WeakSet();
+    let viteBuildLifecycles = 0;
     return {
         name,
         enforce: "pre",
@@ -74,12 +80,23 @@ const unpluginFactory = (rawOptions = {}) => {
                 missingInputs.attach(server);
             },
             // Vite calls buildEnd when the dev server (or build) closes; drop every
-            // poller so a stopped server leaks no watch state.
+            // poller and, once the last overlapping container has closed, every
+            // generation-owned filesystem tracker as well.
             buildEnd() {
                 missingInputs.dispose();
+                if (viteBuildOwners.delete(this)) {
+                    viteBuildLifecycles -= 1;
+                }
+                if (viteBuildLifecycles === 0) {
+                    transform.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

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","resetTtscTransformCache","beginTtscTransformBuild","stripQuery","transformTtsc","createUnplugin","isDeclarationFile"],"mappings":";;;;;;;;;;;AAoBA,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;;;;;;;;;;;AAWG;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;IACnC,IAAI,YAAY,GAAG,IAAI;IAEvB,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;;;;;;;;;gBAS5B,YAAY;AACT,oBAAA,MAA2C,CAAC,MAAM,EAAE,KAAK,KAAK,IAAI;YACvE,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;;;;;;;;;;;;;;;;AAgBR,YAAA,IAAI,WAAW,KAAK,OAAO,IAAI,YAAY,EAAE;gBAC3CC,iCAAuB,CAAC,cAAc,CAAC;YACzC;iBAAO;gBACLC,iCAAuB,CAAC,cAAc,CAAC;YACzC;QACF,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,EAAEP,SAAO,EAAE,OAAO,EAAE,cAAc,EAAE;;;;;;;;;;;AAWnE,gBAAA,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAI;oBAClC,IAAI,WAAW,KAAK,OAAO,IAAI,aAAa,CAAC,OAAO,EAAE,EAAE;;;;AAItD,wBAAA,MAAM,OAAO,GAAG,QAAQ,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC;wBAC5D,IAAI,OAAO,EAAE;AACX,4BAAA,aAAa,CAAC,KAAK,CACjB,OAAO,EACP,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAClB,QAAQ,EAAE,QAAQ,CACnB;4BACD;wBACF;oBACF;;;;;;;AAOA,oBAAA,IAAI,WAAW,KAAK,OAAO,IAAI,CAAC,YAAY,EAAE;wBAC5C;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,GACZQ,yBAAc,CAAC,eAAe;AAyBhC;;;;;;AAMG;AACG,SAAU,iBAAiB,CAAC,EAAU,EAAA;AAC1C,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 { 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';
 
@@ -39,6 +39,12 @@ const unpluginFactory = (rawOptions = {}) => {
     let aliases;
     let viteCommand;
     let viteWatching = true;
+    // 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.
+    const viteBuildOwners = new WeakSet();
+    let viteBuildLifecycles = 0;
     return {
         name,
         enforce: "pre",
@@ -71,12 +77,23 @@ const unpluginFactory = (rawOptions = {}) => {
                 missingInputs.attach(server);
             },
             // Vite calls buildEnd when the dev server (or build) closes; drop every
-            // poller so a stopped server leaks no watch state.
+            // poller and, once the last overlapping container has closed, every
+            // generation-owned filesystem tracker as well.
             buildEnd() {
                 missingInputs.dispose();
+                if (viteBuildOwners.delete(this)) {
+                    viteBuildLifecycles -= 1;
+                }
+                if (viteBuildLifecycles === 0) {
+                    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

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/options.d.cts

@@ -0,0 +1,54 @@
+import type { ITtscProjectPluginConfig } from "ttsc";
+/** Raw compiler-options overlay supplied by the caller as a plain JSON value. */
+export type TtscUnpluginCompilerOptionsJson = Record<string, unknown>;
+/** Options accepted by the `@ttsc/unplugin` bundler adapter. */
+export interface TtscUnpluginOptions {
+    /**
+     * Project config used by the bundler adapter.
+     *
+     * Relative paths resolve from `process.cwd()`. When omitted, the nearest
+     * `tsconfig.json` is discovered from the transformed file.
+     */
+    project?: string;
+    /**
+     * Compiler options overlaid on top of the selected project config.
+     *
+     * This can include `plugins`; `plugins` passed at the top level still wins as
+     * the explicit plugin override.
+     */
+    compilerOptions?: TtscUnpluginCompilerOptionsJson;
+    /**
+     * `ttsc` plugin entries.
+     *
+     * `undefined` reads project plugins from `compilerOptions.plugins` and
+     * directly installed package markers, `false` disables project plugins, and
+     * an array overrides the project plugin list.
+     */
+    plugins?: readonly ITtscProjectPluginConfig[] | false;
+}
+/**
+ * Fully-resolved plugin options with all defaults applied.
+ *
+ * Produced by {@link resolveOptions}; consumed internally by the transform
+ * pipeline. Every field is present and normalised; callers should not construct
+ * this type directly.
+ */
+export interface ResolvedTtscUnpluginOptions {
+    /** Compiler-options overlay applied on top of the discovered tsconfig. */
+    compilerOptions: TtscUnpluginCompilerOptionsJson;
+    /**
+     * Resolved plugin list; mirrors the semantics of
+     * {@link TtscUnpluginOptions.plugins}.
+     */
+    plugins?: readonly ITtscProjectPluginConfig[] | false;
+    /** Resolved path to the project tsconfig, or `undefined` to auto-discover. */
+    project?: string;
+}
+/**
+ * Normalise raw user-supplied options into {@link ResolvedTtscUnpluginOptions}.
+ *
+ * Merges provided values with defaults. The `plugins` field uses an explicit
+ * `"plugins" in options` presence check rather than a falsy guard so that
+ * `plugins: false` (disable all plugins) is preserved as-is.
+ */
+export declare function resolveOptions(options?: TtscUnpluginOptions): ResolvedTtscUnpluginOptions;

package/lib/core/options.d.mts

@@ -0,0 +1,54 @@
+import type { ITtscProjectPluginConfig } from "ttsc";
+/** Raw compiler-options overlay supplied by the caller as a plain JSON value. */
+export type TtscUnpluginCompilerOptionsJson = Record<string, unknown>;
+/** Options accepted by the `@ttsc/unplugin` bundler adapter. */
+export interface TtscUnpluginOptions {
+    /**
+     * Project config used by the bundler adapter.
+     *
+     * Relative paths resolve from `process.cwd()`. When omitted, the nearest
+     * `tsconfig.json` is discovered from the transformed file.
+     */
+    project?: string;
+    /**
+     * Compiler options overlaid on top of the selected project config.
+     *
+     * This can include `plugins`; `plugins` passed at the top level still wins as
+     * the explicit plugin override.
+     */
+    compilerOptions?: TtscUnpluginCompilerOptionsJson;
+    /**
+     * `ttsc` plugin entries.
+     *
+     * `undefined` reads project plugins from `compilerOptions.plugins` and
+     * directly installed package markers, `false` disables project plugins, and
+     * an array overrides the project plugin list.
+     */
+    plugins?: readonly ITtscProjectPluginConfig[] | false;
+}
+/**
+ * Fully-resolved plugin options with all defaults applied.
+ *
+ * Produced by {@link resolveOptions}; consumed internally by the transform
+ * pipeline. Every field is present and normalised; callers should not construct
+ * this type directly.
+ */
+export interface ResolvedTtscUnpluginOptions {
+    /** Compiler-options overlay applied on top of the discovered tsconfig. */
+    compilerOptions: TtscUnpluginCompilerOptionsJson;
+    /**
+     * Resolved plugin list; mirrors the semantics of
+     * {@link TtscUnpluginOptions.plugins}.
+     */
+    plugins?: readonly ITtscProjectPluginConfig[] | false;
+    /** Resolved path to the project tsconfig, or `undefined` to auto-discover. */
+    project?: string;
+}
+/**
+ * Normalise raw user-supplied options into {@link ResolvedTtscUnpluginOptions}.
+ *
+ * Merges provided values with defaults. The `plugins` field uses an explicit
+ * `"plugins" in options` presence check rather than a falsy guard so that
+ * `plugins: false` (disable all plugins) is preserved as-is.
+ */
+export declare function resolveOptions(options?: TtscUnpluginOptions): ResolvedTtscUnpluginOptions;