@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/rollup/createRollupCachedModuleProof.d.ts

@@ -0,0 +1,60 @@
+import type { RollupCachedModuleProof } from "./RollupCachedModuleProof";
+/**
+ * Answer Rollup's cache for the modules the adapter delivers to it.
+ *
+ * When the host would otherwise restore a module from its supplied cache,
+ * shouldTransformCachedModule can request transformation again. This adapter
+ * uses that hook to compare its delivered options and project-record state,
+ * including a build that has no live watcher to hear earlier input edits
+ * (samchon/ttsc#1491).
+ *
+ * A delivery leaves the options it was compiled under, the record, and the
+ * digest of the bytes its process wrote to the record in the module's `meta`
+ * (`TtscRollupDelivery`), which Rollup keeps with the module. A module it would
+ * serve from its cache runs again unless it was compiled under the options the
+ * build runs with and its digest is the record's bytes now. A build that proves
+ * records proves each one once, as its first cached module names it
+ * (`refreshProjectRecordFile`), which moves it for a project that changed while
+ * nothing ran: Rollup reads the cache it was handed as it builds its graph, and
+ * says which modules it holds only by asking here, so the records proven are
+ * exactly those of the projects whose modules it is about to restore. A
+ * watching session proves none: its cache holds only what its own deliveries
+ * registered with the bridge, which moves their records as their inputs change.
+ * An owned module carrying no delivery, or one no cache may serve, runs again,
+ * since nothing proves its output.
+ *
+ * A record read is cached, including unavailable results, until begin clears it
+ * or a first proof attempt invalidates it. Deliveries replace the saved digest
+ * with their own recorded bytes. A later judgment need not reread a record
+ * moved by another process in mid-build; the next pass observes it. A changed
+ * proves callback can invalidate an already read digest within this pass.
+ * Refresh errors propagate after the key enters the attempted-proof set.
+ *
+ * @param name The plugin's name, the key of its entry in a module's `meta`.
+ * @param includes Whether the adapter transforms a module id.
+ * @param options The identity of the options the build runs with
+ *   (`rollupDeliveryOptions`).
+ * @param proves Whether the build proves the records its cached modules name,
+ *   which a build without a watching session's bridge does.
+ * @evidence contracts/common.md#principled-implementation Adapter-owned modules compare options and pass-observed record digest; matching record-less metadata follows the no-project rule. Missing delivery, malformed record, null or unreadable record requests retransformation.
+ * @evidence contracts/common.md#clear-and-simple-design Per-pass proven and digest tables back the existing begin/deliver/moved interface; shared record refresh owns filesystem-state proof.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The adapter uses the host retransformation hook without patching its cache or inventing a record when no proof exists.
+ * @evidence contracts/common.md#meaningful-documentation Paragraphs explain optional record refresh, pass observation reuse and invalidation, including callback failure and record-less delivery semantics.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral record access uses producer-supplied native paths and the shared native record refresh operation, without universal path case normalization or fixed storage directories.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Judgment adds module filtering, current-option work and metadata/text
+ *   comparison. Each lexical record gets one refresh attempt per pass, including
+ *   native input/walk/record I/O work. Digest reads/hash follow record bytes
+ *   and can repeat after proof invalidation; delivery updates avoid a reread.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Modules with the same lexical record reuse a pass's refresh attempt and
+ *   observed digest. Begin ends the window; first refresh invalidates an older
+ *   read and delivery updates the digest. Quiet mid-pass observation is a
+ *   defined reuse window, not independently fresh native state for every module.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The returned proof owner retains attempted keys and optional digests for R
+ *   lexical records until begin clears them or the owner becomes unreachable.
+ *   There is no count/byte cap within a pass or dedicated close. Thrown refresh
+ *   leaves existing table state until that reset; no native handle/task is held.
+ */
+export declare function createRollupCachedModuleProof(name: string, includes: (id: string) => boolean, options: () => string, proves: () => boolean): RollupCachedModuleProof;

package/lib/core/rollup/createRollupCachedModuleProof.js

@@ -0,0 +1,115 @@
+'use strict';
+
+var fs = require('node:fs');
+var projectRecordDigest = require('../bridge/projectRecordDigest.js');
+var refreshProjectRecordFile = require('../bridge/refreshProjectRecordFile.js');
+
+/**
+ * Answer Rollup's cache for the modules the adapter delivers to it.
+ *
+ * When the host would otherwise restore a module from its supplied cache,
+ * shouldTransformCachedModule can request transformation again. This adapter
+ * uses that hook to compare its delivered options and project-record state,
+ * including a build that has no live watcher to hear earlier input edits
+ * (samchon/ttsc#1491).
+ *
+ * A delivery leaves the options it was compiled under, the record, and the
+ * digest of the bytes its process wrote to the record in the module's `meta`
+ * (`TtscRollupDelivery`), which Rollup keeps with the module. A module it would
+ * serve from its cache runs again unless it was compiled under the options the
+ * build runs with and its digest is the record's bytes now. A build that proves
+ * records proves each one once, as its first cached module names it
+ * (`refreshProjectRecordFile`), which moves it for a project that changed while
+ * nothing ran: Rollup reads the cache it was handed as it builds its graph, and
+ * says which modules it holds only by asking here, so the records proven are
+ * exactly those of the projects whose modules it is about to restore. A
+ * watching session proves none: its cache holds only what its own deliveries
+ * registered with the bridge, which moves their records as their inputs change.
+ * An owned module carrying no delivery, or one no cache may serve, runs again,
+ * since nothing proves its output.
+ *
+ * A record read is cached, including unavailable results, until begin clears it
+ * or a first proof attempt invalidates it. Deliveries replace the saved digest
+ * with their own recorded bytes. A later judgment need not reread a record
+ * moved by another process in mid-build; the next pass observes it. A changed
+ * proves callback can invalidate an already read digest within this pass.
+ * Refresh errors propagate after the key enters the attempted-proof set.
+ *
+ * @param name The plugin's name, the key of its entry in a module's `meta`.
+ * @param includes Whether the adapter transforms a module id.
+ * @param options The identity of the options the build runs with
+ *   (`rollupDeliveryOptions`).
+ * @param proves Whether the build proves the records its cached modules name,
+ *   which a build without a watching session's bridge does.
+ * @evidence contracts/common.md#principled-implementation Adapter-owned modules compare options and pass-observed record digest; matching record-less metadata follows the no-project rule. Missing delivery, malformed record, null or unreadable record requests retransformation.
+ * @evidence contracts/common.md#clear-and-simple-design Per-pass proven and digest tables back the existing begin/deliver/moved interface; shared record refresh owns filesystem-state proof.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The adapter uses the host retransformation hook without patching its cache or inventing a record when no proof exists.
+ * @evidence contracts/common.md#meaningful-documentation Paragraphs explain optional record refresh, pass observation reuse and invalidation, including callback failure and record-less delivery semantics.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral record access uses producer-supplied native paths and the shared native record refresh operation, without universal path case normalization or fixed storage directories.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Judgment adds module filtering, current-option work and metadata/text
+ *   comparison. Each lexical record gets one refresh attempt per pass, including
+ *   native input/walk/record I/O work. Digest reads/hash follow record bytes
+ *   and can repeat after proof invalidation; delivery updates avoid a reread.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Modules with the same lexical record reuse a pass's refresh attempt and
+ *   observed digest. Begin ends the window; first refresh invalidates an older
+ *   read and delivery updates the digest. Quiet mid-pass observation is a
+ *   defined reuse window, not independently fresh native state for every module.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The returned proof owner retains attempted keys and optional digests for R
+ *   lexical records until begin clears them or the owner becomes unreachable.
+ *   There is no count/byte cap within a pass or dedicated close. Thrown refresh
+ *   leaves existing table state until that reset; no native handle/task is held.
+ */
+function createRollupCachedModuleProof(name, includes, options, proves) {
+    const proven = new Set();
+    const digests = new Map();
+    const read = (record) => {
+        if (digests.has(record))
+            return digests.get(record);
+        let digest;
+        try {
+            digest = projectRecordDigest.projectRecordDigest(fs.readFileSync(record));
+        }
+        catch {
+            // A record that cannot be read proves nothing.
+        }
+        digests.set(record, digest);
+        return digest;
+    };
+    return {
+        begin: () => {
+            proven.clear();
+            digests.clear();
+        },
+        deliver: (delivery) => {
+            if (delivery?.record !== undefined)
+                digests.set(delivery.record.file, delivery.record.digest);
+            return { [name]: delivery };
+        },
+        moved: ({ id, meta }) => {
+            if (!includes(id))
+                return false;
+            const delivery = meta?.[name];
+            if (delivery?.options !== options())
+                return true;
+            if (delivery.record === undefined)
+                return false;
+            const { digest, file } = (delivery.record ?? {});
+            if (typeof file !== "string" || typeof digest !== "string")
+                return true;
+            if (proves() && !proven.has(file)) {
+                proven.add(file);
+                refreshProjectRecordFile.refreshProjectRecordFile(file);
+                // What a delivery of this build wrote is what the proof ran over, and
+                // a move it made is read from the file.
+                digests.delete(file);
+            }
+            return read(file) !== digest;
+        },
+    };
+}
+
+exports.createRollupCachedModuleProof = createRollupCachedModuleProof;
+//# sourceMappingURL=createRollupCachedModuleProof.js.map

package/lib/core/rollup/createRollupCachedModuleProof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRollupCachedModuleProof.js","sources":["../../../src/core/rollup/createRollupCachedModuleProof.ts"],"sourcesContent":[null],"names":["projectRecordDigest","refreshProjectRecordFile"],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAiC,EACjC,OAAqB,EACrB,MAAqB,EAAA;AAErB,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU;AAChC,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8B;AACrD,IAAA,MAAM,IAAI,GAAG,CAAC,MAAc,KAAwB;AAClD,QAAA,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;AAAE,YAAA,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;AACnD,QAAA,IAAI,MAA0B;AAC9B,QAAA,IAAI;YACF,MAAM,GAAGA,uCAAmB,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QACvD;AAAE,QAAA,MAAM;;QAER;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;AAC3B,QAAA,OAAO,MAAM;AACf,IAAA,CAAC;IACD,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,CAAC,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,EAAE;QACjB,CAAC;AACD,QAAA,OAAO,EAAE,CAAC,QAAQ,KAAI;AACpB,YAAA,IAAI,QAAQ,EAAE,MAAM,KAAK,SAAS;AAChC,gBAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;AAC3D,YAAA,OAAO,EAAE,CAAC,IAAI,GAAG,QAAQ,EAAE;QAC7B,CAAC;QACD,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAI;AACtB,YAAA,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;AAAE,gBAAA,OAAO,KAAK;AAC/B,YAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,CAGf;AACb,YAAA,IAAI,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE;AAAE,gBAAA,OAAO,IAAI;AAChD,YAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS;AAAE,gBAAA,OAAO,KAAK;AAC/C,YAAA,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,IAAI,EAAE,CAE9C;YACD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ;AAAE,gBAAA,OAAO,IAAI;YACvE,IAAI,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACjC,gBAAA,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;gBAChBC,iDAAwB,CAAC,IAAI,CAAC;;;AAG9B,gBAAA,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;YACtB;AACA,YAAA,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,MAAM;QAC9B,CAAC;KACF;AACH;;;;"}

package/lib/core/rollup/createRollupCachedModuleProof.mjs

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import { projectRecordDigest } from '../bridge/projectRecordDigest.mjs';
+import { refreshProjectRecordFile } from '../bridge/refreshProjectRecordFile.mjs';
+
+/**
+ * Answer Rollup's cache for the modules the adapter delivers to it.
+ *
+ * When the host would otherwise restore a module from its supplied cache,
+ * shouldTransformCachedModule can request transformation again. This adapter
+ * uses that hook to compare its delivered options and project-record state,
+ * including a build that has no live watcher to hear earlier input edits
+ * (samchon/ttsc#1491).
+ *
+ * A delivery leaves the options it was compiled under, the record, and the
+ * digest of the bytes its process wrote to the record in the module's `meta`
+ * (`TtscRollupDelivery`), which Rollup keeps with the module. A module it would
+ * serve from its cache runs again unless it was compiled under the options the
+ * build runs with and its digest is the record's bytes now. A build that proves
+ * records proves each one once, as its first cached module names it
+ * (`refreshProjectRecordFile`), which moves it for a project that changed while
+ * nothing ran: Rollup reads the cache it was handed as it builds its graph, and
+ * says which modules it holds only by asking here, so the records proven are
+ * exactly those of the projects whose modules it is about to restore. A
+ * watching session proves none: its cache holds only what its own deliveries
+ * registered with the bridge, which moves their records as their inputs change.
+ * An owned module carrying no delivery, or one no cache may serve, runs again,
+ * since nothing proves its output.
+ *
+ * A record read is cached, including unavailable results, until begin clears it
+ * or a first proof attempt invalidates it. Deliveries replace the saved digest
+ * with their own recorded bytes. A later judgment need not reread a record
+ * moved by another process in mid-build; the next pass observes it. A changed
+ * proves callback can invalidate an already read digest within this pass.
+ * Refresh errors propagate after the key enters the attempted-proof set.
+ *
+ * @param name The plugin's name, the key of its entry in a module's `meta`.
+ * @param includes Whether the adapter transforms a module id.
+ * @param options The identity of the options the build runs with
+ *   (`rollupDeliveryOptions`).
+ * @param proves Whether the build proves the records its cached modules name,
+ *   which a build without a watching session's bridge does.
+ * @evidence contracts/common.md#principled-implementation Adapter-owned modules compare options and pass-observed record digest; matching record-less metadata follows the no-project rule. Missing delivery, malformed record, null or unreadable record requests retransformation.
+ * @evidence contracts/common.md#clear-and-simple-design Per-pass proven and digest tables back the existing begin/deliver/moved interface; shared record refresh owns filesystem-state proof.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The adapter uses the host retransformation hook without patching its cache or inventing a record when no proof exists.
+ * @evidence contracts/common.md#meaningful-documentation Paragraphs explain optional record refresh, pass observation reuse and invalidation, including callback failure and record-less delivery semantics.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral record access uses producer-supplied native paths and the shared native record refresh operation, without universal path case normalization or fixed storage directories.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Judgment adds module filtering, current-option work and metadata/text
+ *   comparison. Each lexical record gets one refresh attempt per pass, including
+ *   native input/walk/record I/O work. Digest reads/hash follow record bytes
+ *   and can repeat after proof invalidation; delivery updates avoid a reread.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Modules with the same lexical record reuse a pass's refresh attempt and
+ *   observed digest. Begin ends the window; first refresh invalidates an older
+ *   read and delivery updates the digest. Quiet mid-pass observation is a
+ *   defined reuse window, not independently fresh native state for every module.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The returned proof owner retains attempted keys and optional digests for R
+ *   lexical records until begin clears them or the owner becomes unreachable.
+ *   There is no count/byte cap within a pass or dedicated close. Thrown refresh
+ *   leaves existing table state until that reset; no native handle/task is held.
+ */
+function createRollupCachedModuleProof(name, includes, options, proves) {
+    const proven = new Set();
+    const digests = new Map();
+    const read = (record) => {
+        if (digests.has(record))
+            return digests.get(record);
+        let digest;
+        try {
+            digest = projectRecordDigest(fs.readFileSync(record));
+        }
+        catch {
+            // A record that cannot be read proves nothing.
+        }
+        digests.set(record, digest);
+        return digest;
+    };
+    return {
+        begin: () => {
+            proven.clear();
+            digests.clear();
+        },
+        deliver: (delivery) => {
+            if (delivery?.record !== undefined)
+                digests.set(delivery.record.file, delivery.record.digest);
+            return { [name]: delivery };
+        },
+        moved: ({ id, meta }) => {
+            if (!includes(id))
+                return false;
+            const delivery = meta?.[name];
+            if (delivery?.options !== options())
+                return true;
+            if (delivery.record === undefined)
+                return false;
+            const { digest, file } = (delivery.record ?? {});
+            if (typeof file !== "string" || typeof digest !== "string")
+                return true;
+            if (proves() && !proven.has(file)) {
+                proven.add(file);
+                refreshProjectRecordFile(file);
+                // What a delivery of this build wrote is what the proof ran over, and
+                // a move it made is read from the file.
+                digests.delete(file);
+            }
+            return read(file) !== digest;
+        },
+    };
+}
+
+export { createRollupCachedModuleProof };
+//# sourceMappingURL=createRollupCachedModuleProof.mjs.map

package/lib/core/rollup/createRollupCachedModuleProof.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRollupCachedModuleProof.mjs","sources":["../../../src/core/rollup/createRollupCachedModuleProof.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAiC,EACjC,OAAqB,EACrB,MAAqB,EAAA;AAErB,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU;AAChC,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8B;AACrD,IAAA,MAAM,IAAI,GAAG,CAAC,MAAc,KAAwB;AAClD,QAAA,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;AAAE,YAAA,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;AACnD,QAAA,IAAI,MAA0B;AAC9B,QAAA,IAAI;YACF,MAAM,GAAG,mBAAmB,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QACvD;AAAE,QAAA,MAAM;;QAER;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;AAC3B,QAAA,OAAO,MAAM;AACf,IAAA,CAAC;IACD,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,CAAC,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,EAAE;QACjB,CAAC;AACD,QAAA,OAAO,EAAE,CAAC,QAAQ,KAAI;AACpB,YAAA,IAAI,QAAQ,EAAE,MAAM,KAAK,SAAS;AAChC,gBAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;AAC3D,YAAA,OAAO,EAAE,CAAC,IAAI,GAAG,QAAQ,EAAE;QAC7B,CAAC;QACD,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAI;AACtB,YAAA,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;AAAE,gBAAA,OAAO,KAAK;AAC/B,YAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,CAGf;AACb,YAAA,IAAI,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE;AAAE,gBAAA,OAAO,IAAI;AAChD,YAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS;AAAE,gBAAA,OAAO,KAAK;AAC/C,YAAA,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,IAAI,EAAE,CAE9C;YACD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ;AAAE,gBAAA,OAAO,IAAI;YACvE,IAAI,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACjC,gBAAA,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;gBAChB,wBAAwB,CAAC,IAAI,CAAC;;;AAG9B,gBAAA,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;YACtB;AACA,YAAA,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,MAAM;QAC9B,CAAC;KACF;AACH;;;;"}

package/lib/core/rollup/rollupDeliveryOptions.d.cts

@@ -0,0 +1,36 @@
+import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions.cjs";
+/**
+ * The identity of the options a delivery to Rollup was compiled under, which
+ * the module carries into Rollup's cache (`TtscRollupDelivery`).
+ *
+ * The identity records alias mappings, compiler overlay, plugin payloads and
+ * configured project and source-root selection. Tsconfig input state is
+ * represented separately by the delivery's project record. A configured project
+ * resolves under the same native cwd rule as explicit selection; it is not
+ * canonicalized to a physical alias or made process-independent across
+ * different cwd spellings.
+ *
+ * Compiler options, plugin payloads and alias mappings preserve their actual
+ * JSON order. Their consumers can observe declaration order; the host cannot
+ * claim equivalence merely by sorting arbitrary configuration keys.
+ *
+ * @param options The plugin instance's resolved options.
+ * @param aliasPaths The aliases the compile is handed (`createAliasPaths`).
+ * @evidence contracts/common.md#principled-implementation Project selection and opaque JSON of the compiler overlay, plugin payloads and alias mappings identify delivered compile options without erasing declaration order observable by the compiler or plugin.
+ * @evidence contracts/common.md#clear-and-simple-design The identity reuses the common serializer and hash helper, leaving tsconfig input state to the project record.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resolving the configured project follows actual selection spelling; no target-specific exception drops relevant compile options.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain why Rollup requires option identity and why the record owns tsconfig state separately.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Resolves configured project and projectRoot with node:path, so their anchors follow
+ *   the host OS.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three opaque JSON payloads are encoded before a fixed-key outer encoding
+ *   and hash pass. Payload entries/emitted bytes, escaping and native project
+ *   anchor lengths drive traversal and temporary strings, not wrapper count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This one identity computation coordinates no cross-call work. The plugin
+ *   instance owns reuse for its fixed options and supplied alias identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function rollupDeliveryOptions(options: ResolvedTtscUnpluginOptions, aliasPaths: Record<string, string[]>): string;

package/lib/core/rollup/rollupDeliveryOptions.d.mts

@@ -0,0 +1,36 @@
+import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions.mjs";
+/**
+ * The identity of the options a delivery to Rollup was compiled under, which
+ * the module carries into Rollup's cache (`TtscRollupDelivery`).
+ *
+ * The identity records alias mappings, compiler overlay, plugin payloads and
+ * configured project and source-root selection. Tsconfig input state is
+ * represented separately by the delivery's project record. A configured project
+ * resolves under the same native cwd rule as explicit selection; it is not
+ * canonicalized to a physical alias or made process-independent across
+ * different cwd spellings.
+ *
+ * Compiler options, plugin payloads and alias mappings preserve their actual
+ * JSON order. Their consumers can observe declaration order; the host cannot
+ * claim equivalence merely by sorting arbitrary configuration keys.
+ *
+ * @param options The plugin instance's resolved options.
+ * @param aliasPaths The aliases the compile is handed (`createAliasPaths`).
+ * @evidence contracts/common.md#principled-implementation Project selection and opaque JSON of the compiler overlay, plugin payloads and alias mappings identify delivered compile options without erasing declaration order observable by the compiler or plugin.
+ * @evidence contracts/common.md#clear-and-simple-design The identity reuses the common serializer and hash helper, leaving tsconfig input state to the project record.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resolving the configured project follows actual selection spelling; no target-specific exception drops relevant compile options.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain why Rollup requires option identity and why the record owns tsconfig state separately.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Resolves configured project and projectRoot with node:path, so their anchors follow
+ *   the host OS.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three opaque JSON payloads are encoded before a fixed-key outer encoding
+ *   and hash pass. Payload entries/emitted bytes, escaping and native project
+ *   anchor lengths drive traversal and temporary strings, not wrapper count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This one identity computation coordinates no cross-call work. The plugin
+ *   instance owns reuse for its fixed options and supplied alias identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function rollupDeliveryOptions(options: ResolvedTtscUnpluginOptions, aliasPaths: Record<string, string[]>): string;

package/lib/core/rollup/rollupDeliveryOptions.d.ts

@@ -0,0 +1,36 @@
+import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions";
+/**
+ * The identity of the options a delivery to Rollup was compiled under, which
+ * the module carries into Rollup's cache (`TtscRollupDelivery`).
+ *
+ * The identity records alias mappings, compiler overlay, plugin payloads and
+ * configured project and source-root selection. Tsconfig input state is
+ * represented separately by the delivery's project record. A configured project
+ * resolves under the same native cwd rule as explicit selection; it is not
+ * canonicalized to a physical alias or made process-independent across
+ * different cwd spellings.
+ *
+ * Compiler options, plugin payloads and alias mappings preserve their actual
+ * JSON order. Their consumers can observe declaration order; the host cannot
+ * claim equivalence merely by sorting arbitrary configuration keys.
+ *
+ * @param options The plugin instance's resolved options.
+ * @param aliasPaths The aliases the compile is handed (`createAliasPaths`).
+ * @evidence contracts/common.md#principled-implementation Project selection and opaque JSON of the compiler overlay, plugin payloads and alias mappings identify delivered compile options without erasing declaration order observable by the compiler or plugin.
+ * @evidence contracts/common.md#clear-and-simple-design The identity reuses the common serializer and hash helper, leaving tsconfig input state to the project record.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resolving the configured project follows actual selection spelling; no target-specific exception drops relevant compile options.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain why Rollup requires option identity and why the record owns tsconfig state separately.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Resolves configured project and projectRoot with node:path, so their anchors follow
+ *   the host OS.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three opaque JSON payloads are encoded before a fixed-key outer encoding
+ *   and hash pass. Payload entries/emitted bytes, escaping and native project
+ *   anchor lengths drive traversal and temporary strings, not wrapper count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This one identity computation coordinates no cross-call work. The plugin
+ *   instance owns reuse for its fixed options and supplied alias identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function rollupDeliveryOptions(options: ResolvedTtscUnpluginOptions, aliasPaths: Record<string, string[]>): string;

package/lib/core/rollup/rollupDeliveryOptions.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var path = require('node:path');
+var hashText = require('../transform/utils/hashText.js');
+var stableStringify = require('../transform/utils/stableStringify.js');
+
+/**
+ * The identity of the options a delivery to Rollup was compiled under, which
+ * the module carries into Rollup's cache (`TtscRollupDelivery`).
+ *
+ * The identity records alias mappings, compiler overlay, plugin payloads and
+ * configured project and source-root selection. Tsconfig input state is
+ * represented separately by the delivery's project record. A configured project
+ * resolves under the same native cwd rule as explicit selection; it is not
+ * canonicalized to a physical alias or made process-independent across
+ * different cwd spellings.
+ *
+ * Compiler options, plugin payloads and alias mappings preserve their actual
+ * JSON order. Their consumers can observe declaration order; the host cannot
+ * claim equivalence merely by sorting arbitrary configuration keys.
+ *
+ * @param options The plugin instance's resolved options.
+ * @param aliasPaths The aliases the compile is handed (`createAliasPaths`).
+ * @evidence contracts/common.md#principled-implementation Project selection and opaque JSON of the compiler overlay, plugin payloads and alias mappings identify delivered compile options without erasing declaration order observable by the compiler or plugin.
+ * @evidence contracts/common.md#clear-and-simple-design The identity reuses the common serializer and hash helper, leaving tsconfig input state to the project record.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resolving the configured project follows actual selection spelling; no target-specific exception drops relevant compile options.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain why Rollup requires option identity and why the record owns tsconfig state separately.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Resolves configured project and projectRoot with node:path, so their anchors follow
+ *   the host OS.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three opaque JSON payloads are encoded before a fixed-key outer encoding
+ *   and hash pass. Payload entries/emitted bytes, escaping and native project
+ *   anchor lengths drive traversal and temporary strings, not wrapper count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This one identity computation coordinates no cross-call work. The plugin
+ *   instance owns reuse for its fixed options and supplied alias identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function rollupDeliveryOptions(options, aliasPaths) {
+    return hashText.hashText(stableStringify.stableStringify({
+        aliasPaths: JSON.stringify(aliasPaths),
+        compilerOptions: JSON.stringify(options.compilerOptions),
+        plugins: JSON.stringify(options.plugins),
+        project: options.project === undefined ? null : path.resolve(options.project),
+        projectRoot: options.projectRoot === undefined
+            ? null
+            : path.resolve(options.projectRoot),
+    }));
+}
+
+exports.rollupDeliveryOptions = rollupDeliveryOptions;
+//# sourceMappingURL=rollupDeliveryOptions.js.map

package/lib/core/rollup/rollupDeliveryOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollupDeliveryOptions.js","sources":["../../../src/core/rollup/rollupDeliveryOptions.ts"],"sourcesContent":[null],"names":["hashText","stableStringify"],"mappings":";;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,qBAAqB,CACnC,OAAoC,EACpC,UAAoC,EAAA;IAEpC,OAAOA,iBAAQ,CACbC,+BAAe,CAAC;AACd,QAAA,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;QACtC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;QACxD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC;QACxC,OAAO,EACL,OAAO,CAAC,OAAO,KAAK,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;AACtE,QAAA,WAAW,EACT,OAAO,CAAC,WAAW,KAAK;AACtB,cAAE;cACA,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;AACxC,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/rollup/rollupDeliveryOptions.mjs

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { hashText } from '../transform/utils/hashText.mjs';
+import { stableStringify } from '../transform/utils/stableStringify.mjs';
+
+/**
+ * The identity of the options a delivery to Rollup was compiled under, which
+ * the module carries into Rollup's cache (`TtscRollupDelivery`).
+ *
+ * The identity records alias mappings, compiler overlay, plugin payloads and
+ * configured project and source-root selection. Tsconfig input state is
+ * represented separately by the delivery's project record. A configured project
+ * resolves under the same native cwd rule as explicit selection; it is not
+ * canonicalized to a physical alias or made process-independent across
+ * different cwd spellings.
+ *
+ * Compiler options, plugin payloads and alias mappings preserve their actual
+ * JSON order. Their consumers can observe declaration order; the host cannot
+ * claim equivalence merely by sorting arbitrary configuration keys.
+ *
+ * @param options The plugin instance's resolved options.
+ * @param aliasPaths The aliases the compile is handed (`createAliasPaths`).
+ * @evidence contracts/common.md#principled-implementation Project selection and opaque JSON of the compiler overlay, plugin payloads and alias mappings identify delivered compile options without erasing declaration order observable by the compiler or plugin.
+ * @evidence contracts/common.md#clear-and-simple-design The identity reuses the common serializer and hash helper, leaving tsconfig input state to the project record.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Resolving the configured project follows actual selection spelling; no target-specific exception drops relevant compile options.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain why Rollup requires option identity and why the record owns tsconfig state separately.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Resolves configured project and projectRoot with node:path, so their anchors follow
+ *   the host OS.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Three opaque JSON payloads are encoded before a fixed-key outer encoding
+ *   and hash pass. Payload entries/emitted bytes, escaping and native project
+ *   anchor lengths drive traversal and temporary strings, not wrapper count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This one identity computation coordinates no cross-call work. The plugin
+ *   instance owns reuse for its fixed options and supplied alias identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function rollupDeliveryOptions(options, aliasPaths) {
+    return hashText(stableStringify({
+        aliasPaths: JSON.stringify(aliasPaths),
+        compilerOptions: JSON.stringify(options.compilerOptions),
+        plugins: JSON.stringify(options.plugins),
+        project: options.project === undefined ? null : path.resolve(options.project),
+        projectRoot: options.projectRoot === undefined
+            ? null
+            : path.resolve(options.projectRoot),
+    }));
+}
+
+export { rollupDeliveryOptions };
+//# sourceMappingURL=rollupDeliveryOptions.mjs.map

package/lib/core/rollup/rollupDeliveryOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollupDeliveryOptions.mjs","sources":["../../../src/core/rollup/rollupDeliveryOptions.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,qBAAqB,CACnC,OAAoC,EACpC,UAAoC,EAAA;IAEpC,OAAO,QAAQ,CACb,eAAe,CAAC;AACd,QAAA,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;QACtC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;QACxD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC;QACxC,OAAO,EACL,OAAO,CAAC,OAAO,KAAK,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;AACtE,QAAA,WAAW,EACT,OAAO,CAAC,WAAW,KAAK;AACtB,cAAE;cACA,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;AACxC,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/rollup/selectRollupCachedModuleTransform.d.cts

@@ -0,0 +1,18 @@
+import type { HostWatchBridge } from "../bridge/HostWatchBridge.cjs";
+import type { RollupCachedModuleProof } from "./RollupCachedModuleProof.cjs";
+/**
+ * Request cached-module transformation while the bridge owes a signal, or when
+ * the module proof reports movement. Return null to leave the host's ordinary
+ * cache decision in place. An owed signal skips module proof evaluation. This
+ * protocol decision does not establish arrival of a native watch event.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an exactly true owed-state answer bypasses module judgment; otherwise the existing moved predicate decides true versus null using the supplied module.
+ * @evidence contracts/common.md#clear-and-simple-design One production-used decision maps the bridge and module-proof owners' answers to the shared Vite/Rollup hook protocol without duplicating their validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fabricated watch state or cache entry replaces those owners' answers; method receivers and exceptions are preserved.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains true/null meaning, short-circuiting and the native-event acquisition limit.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This decision performs no native path interpretation, filesystem access or capability determination; bridge observation and module-record identity remain with their supplied owners.
+ * @evidence contracts/performance.md#efficient-algorithms A true owed answer avoids module proof work. Otherwise one delegated moved judgment may filter module text, derive current option identity or observe/prove its record through the owner's per-pass tables; the fixed branch does not make that delegated work constant cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The decision is evaluated for each hook request; bridge state and qualified per-pass proof reuse belong to their owners, not a cache in this operation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires or retains no watcher, record table or generation; it borrows the two owners for one judgment.
+ */
+export declare function selectRollupCachedModuleTransform(bridge: Pick<HostWatchBridge, "owes"> | undefined, cachedModules: Pick<RollupCachedModuleProof, "moved">, module: Parameters<RollupCachedModuleProof["moved"]>[0]): true | null;

package/lib/core/rollup/selectRollupCachedModuleTransform.d.mts

@@ -0,0 +1,18 @@
+import type { HostWatchBridge } from "../bridge/HostWatchBridge.mjs";
+import type { RollupCachedModuleProof } from "./RollupCachedModuleProof.mjs";
+/**
+ * Request cached-module transformation while the bridge owes a signal, or when
+ * the module proof reports movement. Return null to leave the host's ordinary
+ * cache decision in place. An owed signal skips module proof evaluation. This
+ * protocol decision does not establish arrival of a native watch event.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an exactly true owed-state answer bypasses module judgment; otherwise the existing moved predicate decides true versus null using the supplied module.
+ * @evidence contracts/common.md#clear-and-simple-design One production-used decision maps the bridge and module-proof owners' answers to the shared Vite/Rollup hook protocol without duplicating their validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fabricated watch state or cache entry replaces those owners' answers; method receivers and exceptions are preserved.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains true/null meaning, short-circuiting and the native-event acquisition limit.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This decision performs no native path interpretation, filesystem access or capability determination; bridge observation and module-record identity remain with their supplied owners.
+ * @evidence contracts/performance.md#efficient-algorithms A true owed answer avoids module proof work. Otherwise one delegated moved judgment may filter module text, derive current option identity or observe/prove its record through the owner's per-pass tables; the fixed branch does not make that delegated work constant cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The decision is evaluated for each hook request; bridge state and qualified per-pass proof reuse belong to their owners, not a cache in this operation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires or retains no watcher, record table or generation; it borrows the two owners for one judgment.
+ */
+export declare function selectRollupCachedModuleTransform(bridge: Pick<HostWatchBridge, "owes"> | undefined, cachedModules: Pick<RollupCachedModuleProof, "moved">, module: Parameters<RollupCachedModuleProof["moved"]>[0]): true | null;

package/lib/core/rollup/selectRollupCachedModuleTransform.d.ts

@@ -0,0 +1,18 @@
+import type { HostWatchBridge } from "../bridge/HostWatchBridge";
+import type { RollupCachedModuleProof } from "./RollupCachedModuleProof";
+/**
+ * Request cached-module transformation while the bridge owes a signal, or when
+ * the module proof reports movement. Return null to leave the host's ordinary
+ * cache decision in place. An owed signal skips module proof evaluation. This
+ * protocol decision does not establish arrival of a native watch event.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an exactly true owed-state answer bypasses module judgment; otherwise the existing moved predicate decides true versus null using the supplied module.
+ * @evidence contracts/common.md#clear-and-simple-design One production-used decision maps the bridge and module-proof owners' answers to the shared Vite/Rollup hook protocol without duplicating their validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fabricated watch state or cache entry replaces those owners' answers; method receivers and exceptions are preserved.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains true/null meaning, short-circuiting and the native-event acquisition limit.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This decision performs no native path interpretation, filesystem access or capability determination; bridge observation and module-record identity remain with their supplied owners.
+ * @evidence contracts/performance.md#efficient-algorithms A true owed answer avoids module proof work. Otherwise one delegated moved judgment may filter module text, derive current option identity or observe/prove its record through the owner's per-pass tables; the fixed branch does not make that delegated work constant cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The decision is evaluated for each hook request; bridge state and qualified per-pass proof reuse belong to their owners, not a cache in this operation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires or retains no watcher, record table or generation; it borrows the two owners for one judgment.
+ */
+export declare function selectRollupCachedModuleTransform(bridge: Pick<HostWatchBridge, "owes"> | undefined, cachedModules: Pick<RollupCachedModuleProof, "moved">, module: Parameters<RollupCachedModuleProof["moved"]>[0]): true | null;

package/lib/core/rollup/selectRollupCachedModuleTransform.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Request cached-module transformation while the bridge owes a signal, or when
+ * the module proof reports movement. Return null to leave the host's ordinary
+ * cache decision in place. An owed signal skips module proof evaluation. This
+ * protocol decision does not establish arrival of a native watch event.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an exactly true owed-state answer bypasses module judgment; otherwise the existing moved predicate decides true versus null using the supplied module.
+ * @evidence contracts/common.md#clear-and-simple-design One production-used decision maps the bridge and module-proof owners' answers to the shared Vite/Rollup hook protocol without duplicating their validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fabricated watch state or cache entry replaces those owners' answers; method receivers and exceptions are preserved.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains true/null meaning, short-circuiting and the native-event acquisition limit.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This decision performs no native path interpretation, filesystem access or capability determination; bridge observation and module-record identity remain with their supplied owners.
+ * @evidence contracts/performance.md#efficient-algorithms A true owed answer avoids module proof work. Otherwise one delegated moved judgment may filter module text, derive current option identity or observe/prove its record through the owner's per-pass tables; the fixed branch does not make that delegated work constant cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The decision is evaluated for each hook request; bridge state and qualified per-pass proof reuse belong to their owners, not a cache in this operation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires or retains no watcher, record table or generation; it borrows the two owners for one judgment.
+ */
+function selectRollupCachedModuleTransform(bridge, cachedModules, module) {
+    return bridge?.owes() === true || cachedModules.moved(module) ? true : null;
+}
+
+exports.selectRollupCachedModuleTransform = selectRollupCachedModuleTransform;
+//# sourceMappingURL=selectRollupCachedModuleTransform.js.map

package/lib/core/rollup/selectRollupCachedModuleTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectRollupCachedModuleTransform.js","sources":["../../../src/core/rollup/selectRollupCachedModuleTransform.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;SACa,iCAAiC,CAC/C,MAAiD,EACjD,aAAqD,EACrD,MAAuD,EAAA;IAEvD,OAAO,MAAM,EAAE,IAAI,EAAE,KAAK,IAAI,IAAI,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI;AAC7E;;;;"}