@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/cache/createTransformCacheLease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTransformCacheLease.js","sources":["../../../../src/core/transform/cache/createTransformCacheLease.ts"],"sourcesContent":[null],"names":["resetTtscTransformCache"],"mappings":";;;;AAIA;;;;;;;;;AASG;AACH,MAAM,gBAAgB,GAAG,KAAK;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;SACa,yBAAyB;AACvC;AACA,KAAyB;AACzB;AACA,QAA4C,EAAA;IAE5C,IAAI,MAAM,GAAG,CAAC;AACd,IAAA,IAAI,OAAmC;IACvC,OAAO;QACL,OAAO,GAAA;YACL,QAAQ,EAAE,OAAO,EAAE;YACnB,MAAM,IAAI,CAAC;AACX,YAAA,IAAI,OAAO,KAAK,SAAS,EAAE;gBACzB,YAAY,CAAC,OAAO,CAAC;gBACrB,OAAO,GAAG,SAAS;YACrB;QACF,CAAC;QACD,OAAO,GAAA;YACL,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;AAChC,YAAA,IAAI,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,SAAS;gBAAE;AAC3C,YAAA,OAAO,GAAG,UAAU,CAAC,MAAK;gBACxB,OAAO,GAAG,SAAS;AACnB,gBAAA,IAAI,MAAM,KAAK,CAAC,EAAE;oBAChBA,+CAAuB,CAAC,KAAK,CAAC;oBAC9B,QAAQ,EAAE,IAAI,EAAE;gBAClB;YACF,CAAC,EAAE,gBAAgB,CAAC;YACpB,OAAO,CAAC,KAAK,EAAE;QACjB,CAAC;KACF;AACH;;;;"}

package/lib/core/transform/cache/createTransformCacheLease.mjs

@@ -0,0 +1,86 @@
+import { resetTtscTransformCache } from './resetTtscTransformCache.mjs';
+
+/**
+ * How long a build-scoped generation outlives its last session
+ * (samchon/ttsc#1396).
+ *
+ * Measured with `next build --webpack`, the next compiler applied its plugins
+ * 456 ms after the previous one shut down, and Vite builds an app's
+ * environments back to back. The grace only decides whether the next session
+ * reuses the generation; that session proves it against the filesystem before
+ * serving a module, so the value affects cost, never correctness.
+ */
+const RELEASE_GRACE_MS = 2_000;
+/**
+ * Tie a build-scoped cache's lifetime to the sessions that use it, rather than
+ * to one session (samchon/ttsc#1396).
+ *
+ * A multi-environment `vite build`, and Next's client, server, and edge
+ * compilers, each ran a session of their own over the same program, and each
+ * one discarded the generation at its end, so the next compiled the whole
+ * project again. The cache can retain generation data and clock probes;
+ * generation capture decides whether notification handles are retained. When
+ * the last session releases it, the lease keeps it for a short grace. A session
+ * acquired within that grace opens its own delivery pass, and the pass's first
+ * delivery proves the kept generation against the filesystem. The grace
+ * callback resets a cache still unowned when it runs; event-loop scheduling is
+ * not a wall-clock cleanup deadline. Optional registry hooks observe
+ * acquisition and final idle reclamation; they do not change the generation's
+ * validation or the lease's owner count.
+ *
+ * @evidence contracts/common.md#principled-implementation Active-session counting prevents premature reset, and final release schedules a grace timer whose callback rechecks ownership before resetting the generation.
+ * @evidence contracts/common.md#clear-and-simple-design One counter and one pending timer represent active ownership and the between-session grace; reacquisition cancels that timer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The measured grace controls reuse cost only; it cannot replace the new pass's filesystem proof or manufacture a valid generation.
+ * @evidence contracts/common.md#meaningful-documentation Separate paragraphs explain repeated-host compile cost, retained generation/probe responsibility and proof required by a reacquiring session, without promising a timer execution deadline.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Acquisition/release update one counter and pending timer without scanning
+ *   entries. Registry hooks add their caller-owned work. Final idle callback
+ *   resets N cached promises, with O(N) snapshot/cleanup scheduling and delegated
+ *   generation watcher/probe disposal as fulfilled promises settle.
+ * @evidence contracts/performance.md#reuse-equivalent-work Adjacent compiler sessions share the cache through teardown gaps; a new pass still proves input equivalence before serving output.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One pending timer captures the cache/registry, is cancelled on reacquisition
+ *   and is unreferenced so it does not keep the process alive. Final idle reset
+ *   clears membership and schedules fulfilled generation cleanup; unresolved
+ *   compiles still have no lease cancellation deadline. Cache entries/bytes
+ *   are not capacity-bounded here, and callback delay can extend retention.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The standard Node timer controls ownership grace, while generation disposal
+ *   closes supplied native notification capabilities and owned clock probes.
+ *   Scheduling adds no filesystem or OS-name reliability assumption, and the
+ *   lease does not reinterpret the generation's actual observing view.
+ */
+function createTransformCacheLease(
+/** Cache retained across sessions and reset by final idle reclamation. */
+cache, 
+/** Optional registration hooks; their failures/work remain caller-owned. */
+registry) {
+    let owners = 0;
+    let pending;
+    return {
+        acquire() {
+            registry?.acquire();
+            owners += 1;
+            if (pending !== undefined) {
+                clearTimeout(pending);
+                pending = undefined;
+            }
+        },
+        release() {
+            owners = Math.max(0, owners - 1);
+            if (owners !== 0 || pending !== undefined)
+                return;
+            pending = setTimeout(() => {
+                pending = undefined;
+                if (owners === 0) {
+                    resetTtscTransformCache(cache);
+                    registry?.idle();
+                }
+            }, RELEASE_GRACE_MS);
+            pending.unref();
+        },
+    };
+}
+
+export { createTransformCacheLease };
+//# sourceMappingURL=createTransformCacheLease.mjs.map

package/lib/core/transform/cache/createTransformCacheLease.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTransformCacheLease.mjs","sources":["../../../../src/core/transform/cache/createTransformCacheLease.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;AASG;AACH,MAAM,gBAAgB,GAAG,KAAK;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;SACa,yBAAyB;AACvC;AACA,KAAyB;AACzB;AACA,QAA4C,EAAA;IAE5C,IAAI,MAAM,GAAG,CAAC;AACd,IAAA,IAAI,OAAmC;IACvC,OAAO;QACL,OAAO,GAAA;YACL,QAAQ,EAAE,OAAO,EAAE;YACnB,MAAM,IAAI,CAAC;AACX,YAAA,IAAI,OAAO,KAAK,SAAS,EAAE;gBACzB,YAAY,CAAC,OAAO,CAAC;gBACrB,OAAO,GAAG,SAAS;YACrB;QACF,CAAC;QACD,OAAO,GAAA;YACL,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;AAChC,YAAA,IAAI,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,SAAS;gBAAE;AAC3C,YAAA,OAAO,GAAG,UAAU,CAAC,MAAK;gBACxB,OAAO,GAAG,SAAS;AACnB,gBAAA,IAAI,MAAM,KAAK,CAAC,EAAE;oBAChB,uBAAuB,CAAC,KAAK,CAAC;oBAC9B,QAAQ,EAAE,IAAI,EAAE;gBAClB;YACF,CAAC,EAAE,gBAAgB,CAAC;YACpB,OAAO,CAAC,KAAK,EAAE;QACjB,CAAC;KACF;AACH;;;;"}

package/lib/core/transform/cache/createTtscTransformCache.d.cts

@@ -0,0 +1,41 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Create an empty persistent transform cache with isolated filesystem reads.
+ *
+ * The default raw directory capability lists byte names and classifies each
+ * Buffer child path with non-following lstat. This avoids assuming that every
+ * runtime implements raw withFileTypes entries as Node Dirents. Listing or
+ * classification errors still reach the proof consumer. Calling the capability
+ * costs one listing and one lstat per entry; cache construction does not
+ * perform those queries. Explicit overrides and unavailable capabilities stay
+ * intact.
+ *
+ * @evidence contracts/common.md#principled-implementation Each cache receives its own filesystem operation table, so supplied capabilities govern that cache without changing defaults for other adapters. Its default raw directory operation combines native byte names with non-following lstat kinds rather than assuming a runtime-specific raw Dirent representation.
+ * @evidence contracts/common.md#clear-and-simple-design A Map stores compile promises and a WeakMap stores its operation table; omitted operations independently use the native defaults. Raw directory and link reads also reach the table; explicitly supplied undefined for these optional capabilities preserves unsupported authority rather than enabling a native fallback. One private native adapter owns raw name/kind normalization; predicate encoding remains in its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit dependency injection supplies filesystem capabilities without replacing foreign methods or adding test-specific behavior. Native predicate replay receives the caller's raw directory/link functions; an explicitly unavailable optional function remains unavailable. The default adapter does not decode names, infer kinds, replace failed observations or recognize fixture inputs.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the empty cache and isolated reads; the parameter type distinguishes required native defaults from optional watch and case-policy capabilities. Native paragraphs also distinguish the raw backend's deferred listing/classification cost and error propagation from construction.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed capability table follows the cache through a weak association;
+ *   supplied functions may retain caller-owned state. Map entries grow with
+ *   configuration keys without a factory-imposed capacity.
+ *   The default raw callback returns caller-owned entry/stat closures with
+ *   storage proportional to the observed entries and name bytes; synchronous
+ *   filesystem calls release their handles before returning. The cache owner
+ *   removes generations through eviction/reset and their disposer attempts
+ *   watcher/probe cleanup; creation acquires no independent native handle.
+ * @evidence contracts/performance.md#efficient-algorithms Construction allocates one Map and one fixed operation table. Calling its default raw directory callback performs one listing and one lstat per entry, O(n) native queries and O(total name bytes plus n) retained entry data; predicate sorting remains in the consumer.
+ * @evidence contracts/performance.md#reuse-equivalent-work Creates a new cache by definition; sharing one between adapters is decided by sharedBuildTransformCache. The default raw callback observes current membership and kind on each call and adds no independently retained directory memo.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Supplied read and identity capabilities override native defaults per field;
+ *   case/platform policy and watch remain optional capabilities for consumers.
+ *   The constructor copies references without changing global Node operations
+ *   or guessing native case/notification authority from an OS name. Callers
+ *   supplying a mixed view remain responsible for coherent observations. The
+ *   default raw adapter resolves the directory before joining native Buffer
+ *   child paths, preserving drive-relative coordinates without decoding names;
+ *   lstat distinguishes links from their targets and readlink retains bytes.
+ */
+export declare function createTtscTransformCache(
+/** Optional observing capabilities; omitted required reads use host defaults. */
+operations?: Partial<TtscTransformFilesystemOperations>): TtscTransformCache;

package/lib/core/transform/cache/createTtscTransformCache.d.mts

@@ -0,0 +1,41 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Create an empty persistent transform cache with isolated filesystem reads.
+ *
+ * The default raw directory capability lists byte names and classifies each
+ * Buffer child path with non-following lstat. This avoids assuming that every
+ * runtime implements raw withFileTypes entries as Node Dirents. Listing or
+ * classification errors still reach the proof consumer. Calling the capability
+ * costs one listing and one lstat per entry; cache construction does not
+ * perform those queries. Explicit overrides and unavailable capabilities stay
+ * intact.
+ *
+ * @evidence contracts/common.md#principled-implementation Each cache receives its own filesystem operation table, so supplied capabilities govern that cache without changing defaults for other adapters. Its default raw directory operation combines native byte names with non-following lstat kinds rather than assuming a runtime-specific raw Dirent representation.
+ * @evidence contracts/common.md#clear-and-simple-design A Map stores compile promises and a WeakMap stores its operation table; omitted operations independently use the native defaults. Raw directory and link reads also reach the table; explicitly supplied undefined for these optional capabilities preserves unsupported authority rather than enabling a native fallback. One private native adapter owns raw name/kind normalization; predicate encoding remains in its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit dependency injection supplies filesystem capabilities without replacing foreign methods or adding test-specific behavior. Native predicate replay receives the caller's raw directory/link functions; an explicitly unavailable optional function remains unavailable. The default adapter does not decode names, infer kinds, replace failed observations or recognize fixture inputs.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the empty cache and isolated reads; the parameter type distinguishes required native defaults from optional watch and case-policy capabilities. Native paragraphs also distinguish the raw backend's deferred listing/classification cost and error propagation from construction.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed capability table follows the cache through a weak association;
+ *   supplied functions may retain caller-owned state. Map entries grow with
+ *   configuration keys without a factory-imposed capacity.
+ *   The default raw callback returns caller-owned entry/stat closures with
+ *   storage proportional to the observed entries and name bytes; synchronous
+ *   filesystem calls release their handles before returning. The cache owner
+ *   removes generations through eviction/reset and their disposer attempts
+ *   watcher/probe cleanup; creation acquires no independent native handle.
+ * @evidence contracts/performance.md#efficient-algorithms Construction allocates one Map and one fixed operation table. Calling its default raw directory callback performs one listing and one lstat per entry, O(n) native queries and O(total name bytes plus n) retained entry data; predicate sorting remains in the consumer.
+ * @evidence contracts/performance.md#reuse-equivalent-work Creates a new cache by definition; sharing one between adapters is decided by sharedBuildTransformCache. The default raw callback observes current membership and kind on each call and adds no independently retained directory memo.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Supplied read and identity capabilities override native defaults per field;
+ *   case/platform policy and watch remain optional capabilities for consumers.
+ *   The constructor copies references without changing global Node operations
+ *   or guessing native case/notification authority from an OS name. Callers
+ *   supplying a mixed view remain responsible for coherent observations. The
+ *   default raw adapter resolves the directory before joining native Buffer
+ *   child paths, preserving drive-relative coordinates without decoding names;
+ *   lstat distinguishes links from their targets and readlink retains bytes.
+ */
+export declare function createTtscTransformCache(
+/** Optional observing capabilities; omitted required reads use host defaults. */
+operations?: Partial<TtscTransformFilesystemOperations>): TtscTransformCache;

package/lib/core/transform/cache/createTtscTransformCache.d.ts

@@ -0,0 +1,41 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Create an empty persistent transform cache with isolated filesystem reads.
+ *
+ * The default raw directory capability lists byte names and classifies each
+ * Buffer child path with non-following lstat. This avoids assuming that every
+ * runtime implements raw withFileTypes entries as Node Dirents. Listing or
+ * classification errors still reach the proof consumer. Calling the capability
+ * costs one listing and one lstat per entry; cache construction does not
+ * perform those queries. Explicit overrides and unavailable capabilities stay
+ * intact.
+ *
+ * @evidence contracts/common.md#principled-implementation Each cache receives its own filesystem operation table, so supplied capabilities govern that cache without changing defaults for other adapters. Its default raw directory operation combines native byte names with non-following lstat kinds rather than assuming a runtime-specific raw Dirent representation.
+ * @evidence contracts/common.md#clear-and-simple-design A Map stores compile promises and a WeakMap stores its operation table; omitted operations independently use the native defaults. Raw directory and link reads also reach the table; explicitly supplied undefined for these optional capabilities preserves unsupported authority rather than enabling a native fallback. One private native adapter owns raw name/kind normalization; predicate encoding remains in its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit dependency injection supplies filesystem capabilities without replacing foreign methods or adding test-specific behavior. Native predicate replay receives the caller's raw directory/link functions; an explicitly unavailable optional function remains unavailable. The default adapter does not decode names, infer kinds, replace failed observations or recognize fixture inputs.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the empty cache and isolated reads; the parameter type distinguishes required native defaults from optional watch and case-policy capabilities. Native paragraphs also distinguish the raw backend's deferred listing/classification cost and error propagation from construction.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed capability table follows the cache through a weak association;
+ *   supplied functions may retain caller-owned state. Map entries grow with
+ *   configuration keys without a factory-imposed capacity.
+ *   The default raw callback returns caller-owned entry/stat closures with
+ *   storage proportional to the observed entries and name bytes; synchronous
+ *   filesystem calls release their handles before returning. The cache owner
+ *   removes generations through eviction/reset and their disposer attempts
+ *   watcher/probe cleanup; creation acquires no independent native handle.
+ * @evidence contracts/performance.md#efficient-algorithms Construction allocates one Map and one fixed operation table. Calling its default raw directory callback performs one listing and one lstat per entry, O(n) native queries and O(total name bytes plus n) retained entry data; predicate sorting remains in the consumer.
+ * @evidence contracts/performance.md#reuse-equivalent-work Creates a new cache by definition; sharing one between adapters is decided by sharedBuildTransformCache. The default raw callback observes current membership and kind on each call and adds no independently retained directory memo.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Supplied read and identity capabilities override native defaults per field;
+ *   case/platform policy and watch remain optional capabilities for consumers.
+ *   The constructor copies references without changing global Node operations
+ *   or guessing native case/notification authority from an OS name. Callers
+ *   supplying a mixed view remain responsible for coherent observations. The
+ *   default raw adapter resolves the directory before joining native Buffer
+ *   child paths, preserving drive-relative coordinates without decoding names;
+ *   lstat distinguishes links from their targets and readlink retains bytes.
+ */
+export declare function createTtscTransformCache(
+/** Optional observing capabilities; omitted required reads use host defaults. */
+operations?: Partial<TtscTransformFilesystemOperations>): TtscTransformCache;

package/lib/core/transform/cache/createTtscTransformCache.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var TRANSFORM_CACHE_FILESYSTEM = require('./TRANSFORM_CACHE_FILESYSTEM.js');
+
+/**
+ * Create an empty persistent transform cache with isolated filesystem reads.
+ *
+ * The default raw directory capability lists byte names and classifies each
+ * Buffer child path with non-following lstat. This avoids assuming that every
+ * runtime implements raw withFileTypes entries as Node Dirents. Listing or
+ * classification errors still reach the proof consumer. Calling the capability
+ * costs one listing and one lstat per entry; cache construction does not
+ * perform those queries. Explicit overrides and unavailable capabilities stay
+ * intact.
+ *
+ * @evidence contracts/common.md#principled-implementation Each cache receives its own filesystem operation table, so supplied capabilities govern that cache without changing defaults for other adapters. Its default raw directory operation combines native byte names with non-following lstat kinds rather than assuming a runtime-specific raw Dirent representation.
+ * @evidence contracts/common.md#clear-and-simple-design A Map stores compile promises and a WeakMap stores its operation table; omitted operations independently use the native defaults. Raw directory and link reads also reach the table; explicitly supplied undefined for these optional capabilities preserves unsupported authority rather than enabling a native fallback. One private native adapter owns raw name/kind normalization; predicate encoding remains in its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit dependency injection supplies filesystem capabilities without replacing foreign methods or adding test-specific behavior. Native predicate replay receives the caller's raw directory/link functions; an explicitly unavailable optional function remains unavailable. The default adapter does not decode names, infer kinds, replace failed observations or recognize fixture inputs.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the empty cache and isolated reads; the parameter type distinguishes required native defaults from optional watch and case-policy capabilities. Native paragraphs also distinguish the raw backend's deferred listing/classification cost and error propagation from construction.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed capability table follows the cache through a weak association;
+ *   supplied functions may retain caller-owned state. Map entries grow with
+ *   configuration keys without a factory-imposed capacity.
+ *   The default raw callback returns caller-owned entry/stat closures with
+ *   storage proportional to the observed entries and name bytes; synchronous
+ *   filesystem calls release their handles before returning. The cache owner
+ *   removes generations through eviction/reset and their disposer attempts
+ *   watcher/probe cleanup; creation acquires no independent native handle.
+ * @evidence contracts/performance.md#efficient-algorithms Construction allocates one Map and one fixed operation table. Calling its default raw directory callback performs one listing and one lstat per entry, O(n) native queries and O(total name bytes plus n) retained entry data; predicate sorting remains in the consumer.
+ * @evidence contracts/performance.md#reuse-equivalent-work Creates a new cache by definition; sharing one between adapters is decided by sharedBuildTransformCache. The default raw callback observes current membership and kind on each call and adds no independently retained directory memo.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Supplied read and identity capabilities override native defaults per field;
+ *   case/platform policy and watch remain optional capabilities for consumers.
+ *   The constructor copies references without changing global Node operations
+ *   or guessing native case/notification authority from an OS name. Callers
+ *   supplying a mixed view remain responsible for coherent observations. The
+ *   default raw adapter resolves the directory before joining native Buffer
+ *   child paths, preserving drive-relative coordinates without decoding names;
+ *   lstat distinguishes links from their targets and readlink retains bytes.
+ */
+function createTtscTransformCache(
+/** Optional observing capabilities; omitted required reads use host defaults. */
+operations = {}) {
+    const cache = new Map();
+    TRANSFORM_CACHE_FILESYSTEM.TRANSFORM_CACHE_FILESYSTEM.set(cache, {
+        caseSensitive: operations.caseSensitive,
+        exists: operations.exists ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.exists,
+        lstat: operations.lstat ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.lstat,
+        readFile: operations.readFile ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.readFile,
+        readdir: operations.readdir ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.readdir,
+        readlink: Object.hasOwn(operations, "readlink")
+            ? operations.readlink
+            : DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.readlink,
+        readdirRaw: Object.hasOwn(operations, "readdirRaw")
+            ? operations.readdirRaw
+            : DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.readdirRaw,
+        realpath: operations.realpath ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.realpath,
+        stat: operations.stat ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.stat,
+        statBigInt: operations.statBigInt ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS.statBigInt,
+        platform: operations.platform,
+        watch: operations.watch,
+    });
+    return cache;
+}
+
+exports.createTtscTransformCache = createTtscTransformCache;
+//# sourceMappingURL=createTtscTransformCache.js.map

package/lib/core/transform/cache/createTtscTransformCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTtscTransformCache.js","sources":["../../../../src/core/transform/cache/createTtscTransformCache.ts"],"sourcesContent":[null],"names":["TRANSFORM_CACHE_FILESYSTEM","DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;SACa,wBAAwB;AACtC;AACA,UAAA,GAAyD,EAAE,EAAA;AAE3D,IAAA,MAAM,KAAK,GAAuB,IAAI,GAAG,EAAE;AAC3C,IAAAA,qDAA0B,CAAC,GAAG,CAAC,KAAK,EAAE;QACpC,aAAa,EAAE,UAAU,CAAC,aAAa;AACvC,QAAA,MAAM,EAAE,UAAU,CAAC,MAAM,IAAIC,2DAA6B,CAAC,MAAM;AACjE,QAAA,KAAK,EAAE,UAAU,CAAC,KAAK,IAAIA,2DAA6B,CAAC,KAAK;AAC9D,QAAA,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAIA,2DAA6B,CAAC,QAAQ;AACvE,QAAA,OAAO,EAAE,UAAU,CAAC,OAAO,IAAIA,2DAA6B,CAAC,OAAO;QACpE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU;cAC1C,UAAU,CAAC;cACXA,2DAA6B,CAAC,QAAQ;QAC1C,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY;cAC9C,UAAU,CAAC;cACXA,2DAA6B,CAAC,UAAU;AAC5C,QAAA,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAIA,2DAA6B,CAAC,QAAQ;AACvE,QAAA,IAAI,EAAE,UAAU,CAAC,IAAI,IAAIA,2DAA6B,CAAC,IAAI;AAC3D,QAAA,UAAU,EACR,UAAU,CAAC,UAAU,IAAIA,2DAA6B,CAAC,UAAU;QACnE,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,KAAK,EAAE,UAAU,CAAC,KAAK;AACxB,KAAA,CAAC;AACF,IAAA,OAAO,KAAK;AACd;;;;"}

package/lib/core/transform/cache/createTtscTransformCache.mjs

@@ -0,0 +1,66 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { TRANSFORM_CACHE_FILESYSTEM } from './TRANSFORM_CACHE_FILESYSTEM.mjs';
+
+/**
+ * Create an empty persistent transform cache with isolated filesystem reads.
+ *
+ * The default raw directory capability lists byte names and classifies each
+ * Buffer child path with non-following lstat. This avoids assuming that every
+ * runtime implements raw withFileTypes entries as Node Dirents. Listing or
+ * classification errors still reach the proof consumer. Calling the capability
+ * costs one listing and one lstat per entry; cache construction does not
+ * perform those queries. Explicit overrides and unavailable capabilities stay
+ * intact.
+ *
+ * @evidence contracts/common.md#principled-implementation Each cache receives its own filesystem operation table, so supplied capabilities govern that cache without changing defaults for other adapters. Its default raw directory operation combines native byte names with non-following lstat kinds rather than assuming a runtime-specific raw Dirent representation.
+ * @evidence contracts/common.md#clear-and-simple-design A Map stores compile promises and a WeakMap stores its operation table; omitted operations independently use the native defaults. Raw directory and link reads also reach the table; explicitly supplied undefined for these optional capabilities preserves unsupported authority rather than enabling a native fallback. One private native adapter owns raw name/kind normalization; predicate encoding remains in its consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit dependency injection supplies filesystem capabilities without replacing foreign methods or adding test-specific behavior. Native predicate replay receives the caller's raw directory/link functions; an explicitly unavailable optional function remains unavailable. The default adapter does not decode names, infer kinds, replace failed observations or recognize fixture inputs.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the empty cache and isolated reads; the parameter type distinguishes required native defaults from optional watch and case-policy capabilities. Native paragraphs also distinguish the raw backend's deferred listing/classification cost and error propagation from construction.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed capability table follows the cache through a weak association;
+ *   supplied functions may retain caller-owned state. Map entries grow with
+ *   configuration keys without a factory-imposed capacity.
+ *   The default raw callback returns caller-owned entry/stat closures with
+ *   storage proportional to the observed entries and name bytes; synchronous
+ *   filesystem calls release their handles before returning. The cache owner
+ *   removes generations through eviction/reset and their disposer attempts
+ *   watcher/probe cleanup; creation acquires no independent native handle.
+ * @evidence contracts/performance.md#efficient-algorithms Construction allocates one Map and one fixed operation table. Calling its default raw directory callback performs one listing and one lstat per entry, O(n) native queries and O(total name bytes plus n) retained entry data; predicate sorting remains in the consumer.
+ * @evidence contracts/performance.md#reuse-equivalent-work Creates a new cache by definition; sharing one between adapters is decided by sharedBuildTransformCache. The default raw callback observes current membership and kind on each call and adds no independently retained directory memo.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Supplied read and identity capabilities override native defaults per field;
+ *   case/platform policy and watch remain optional capabilities for consumers.
+ *   The constructor copies references without changing global Node operations
+ *   or guessing native case/notification authority from an OS name. Callers
+ *   supplying a mixed view remain responsible for coherent observations. The
+ *   default raw adapter resolves the directory before joining native Buffer
+ *   child paths, preserving drive-relative coordinates without decoding names;
+ *   lstat distinguishes links from their targets and readlink retains bytes.
+ */
+function createTtscTransformCache(
+/** Optional observing capabilities; omitted required reads use host defaults. */
+operations = {}) {
+    const cache = new Map();
+    TRANSFORM_CACHE_FILESYSTEM.set(cache, {
+        caseSensitive: operations.caseSensitive,
+        exists: operations.exists ?? DEFAULT_FILESYSTEM_OPERATIONS.exists,
+        lstat: operations.lstat ?? DEFAULT_FILESYSTEM_OPERATIONS.lstat,
+        readFile: operations.readFile ?? DEFAULT_FILESYSTEM_OPERATIONS.readFile,
+        readdir: operations.readdir ?? DEFAULT_FILESYSTEM_OPERATIONS.readdir,
+        readlink: Object.hasOwn(operations, "readlink")
+            ? operations.readlink
+            : DEFAULT_FILESYSTEM_OPERATIONS.readlink,
+        readdirRaw: Object.hasOwn(operations, "readdirRaw")
+            ? operations.readdirRaw
+            : DEFAULT_FILESYSTEM_OPERATIONS.readdirRaw,
+        realpath: operations.realpath ?? DEFAULT_FILESYSTEM_OPERATIONS.realpath,
+        stat: operations.stat ?? DEFAULT_FILESYSTEM_OPERATIONS.stat,
+        statBigInt: operations.statBigInt ?? DEFAULT_FILESYSTEM_OPERATIONS.statBigInt,
+        platform: operations.platform,
+        watch: operations.watch,
+    });
+    return cache;
+}
+
+export { createTtscTransformCache };
+//# sourceMappingURL=createTtscTransformCache.mjs.map

package/lib/core/transform/cache/createTtscTransformCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTtscTransformCache.mjs","sources":["../../../../src/core/transform/cache/createTtscTransformCache.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;SACa,wBAAwB;AACtC;AACA,UAAA,GAAyD,EAAE,EAAA;AAE3D,IAAA,MAAM,KAAK,GAAuB,IAAI,GAAG,EAAE;AAC3C,IAAA,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE;QACpC,aAAa,EAAE,UAAU,CAAC,aAAa;AACvC,QAAA,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,6BAA6B,CAAC,MAAM;AACjE,QAAA,KAAK,EAAE,UAAU,CAAC,KAAK,IAAI,6BAA6B,CAAC,KAAK;AAC9D,QAAA,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,6BAA6B,CAAC,QAAQ;AACvE,QAAA,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,6BAA6B,CAAC,OAAO;QACpE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU;cAC1C,UAAU,CAAC;cACX,6BAA6B,CAAC,QAAQ;QAC1C,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY;cAC9C,UAAU,CAAC;cACX,6BAA6B,CAAC,UAAU;AAC5C,QAAA,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,6BAA6B,CAAC,QAAQ;AACvE,QAAA,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,6BAA6B,CAAC,IAAI;AAC3D,QAAA,UAAU,EACR,UAAU,CAAC,UAAU,IAAI,6BAA6B,CAAC,UAAU;QACnE,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,KAAK,EAAE,UAAU,CAAC,KAAK;AACxB,KAAA,CAAC;AACF,IAAA,OAAO,KAAK;AACd;;;;"}

package/lib/core/transform/cache/declareTtscTransformPolling.d.cts

@@ -0,0 +1,31 @@
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Record whether the host that owns `cache` watches by polling.
+ *
+ * Called whenever the host's configuration resolves, since a plugin instance
+ * can be reused across servers with different watch options. A generation the
+ * cache captures afterwards opens no retained watcher under polling. One
+ * captured before, with native watchers, gives them up when the next delivery
+ * examines that retained generation and is proven from its recorded state
+ * instead (samchon/ttsc#1542). This policy update does not itself close
+ * handles.
+ *
+ * @param cache The persistent transform cache.
+ * @param polling Whether the host polls, typically from `hostDeclaresPolling`.
+ * @evidence contracts/common.md#principled-implementation Polling declaration is updated per resolved host configuration, so a reused plugin instance cannot retain an earlier server's notification assumption.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-keyed WeakSet records the policy; generation creation and withdrawal own watcher changes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Polling requires recorded-state validation rather than treating absent native events as freshness proof.
+ * @evidence contracts/common.md#meaningful-documentation The prose describes both newly captured and already retained generations under a changed host watch policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A cache owns at most one weak polling membership, inserted on true and
+ *   removed on false; it does not retain the cache. Generation owners acquire
+ *   or withdraw native handles when they consume this policy, not here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A WeakSet insert or delete.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It records a policy and does not discard or reuse a computation; a generation captured earlier gives up its watchers at its next delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The host supplies its actual polling choice rather than this operation
+ *   inferring mount reliability from OS names or path prefixes. Consumers
+ *   separately qualify native backend capabilities; clearing polling permits
+ *   notification admission but does not establish trustworthy silence.
+ */
+export declare function declareTtscTransformPolling(cache: TtscTransformCache, polling: boolean): void;

package/lib/core/transform/cache/declareTtscTransformPolling.d.mts

@@ -0,0 +1,31 @@
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Record whether the host that owns `cache` watches by polling.
+ *
+ * Called whenever the host's configuration resolves, since a plugin instance
+ * can be reused across servers with different watch options. A generation the
+ * cache captures afterwards opens no retained watcher under polling. One
+ * captured before, with native watchers, gives them up when the next delivery
+ * examines that retained generation and is proven from its recorded state
+ * instead (samchon/ttsc#1542). This policy update does not itself close
+ * handles.
+ *
+ * @param cache The persistent transform cache.
+ * @param polling Whether the host polls, typically from `hostDeclaresPolling`.
+ * @evidence contracts/common.md#principled-implementation Polling declaration is updated per resolved host configuration, so a reused plugin instance cannot retain an earlier server's notification assumption.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-keyed WeakSet records the policy; generation creation and withdrawal own watcher changes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Polling requires recorded-state validation rather than treating absent native events as freshness proof.
+ * @evidence contracts/common.md#meaningful-documentation The prose describes both newly captured and already retained generations under a changed host watch policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A cache owns at most one weak polling membership, inserted on true and
+ *   removed on false; it does not retain the cache. Generation owners acquire
+ *   or withdraw native handles when they consume this policy, not here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A WeakSet insert or delete.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It records a policy and does not discard or reuse a computation; a generation captured earlier gives up its watchers at its next delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The host supplies its actual polling choice rather than this operation
+ *   inferring mount reliability from OS names or path prefixes. Consumers
+ *   separately qualify native backend capabilities; clearing polling permits
+ *   notification admission but does not establish trustworthy silence.
+ */
+export declare function declareTtscTransformPolling(cache: TtscTransformCache, polling: boolean): void;

package/lib/core/transform/cache/declareTtscTransformPolling.d.ts

@@ -0,0 +1,31 @@
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Record whether the host that owns `cache` watches by polling.
+ *
+ * Called whenever the host's configuration resolves, since a plugin instance
+ * can be reused across servers with different watch options. A generation the
+ * cache captures afterwards opens no retained watcher under polling. One
+ * captured before, with native watchers, gives them up when the next delivery
+ * examines that retained generation and is proven from its recorded state
+ * instead (samchon/ttsc#1542). This policy update does not itself close
+ * handles.
+ *
+ * @param cache The persistent transform cache.
+ * @param polling Whether the host polls, typically from `hostDeclaresPolling`.
+ * @evidence contracts/common.md#principled-implementation Polling declaration is updated per resolved host configuration, so a reused plugin instance cannot retain an earlier server's notification assumption.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-keyed WeakSet records the policy; generation creation and withdrawal own watcher changes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Polling requires recorded-state validation rather than treating absent native events as freshness proof.
+ * @evidence contracts/common.md#meaningful-documentation The prose describes both newly captured and already retained generations under a changed host watch policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A cache owns at most one weak polling membership, inserted on true and
+ *   removed on false; it does not retain the cache. Generation owners acquire
+ *   or withdraw native handles when they consume this policy, not here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A WeakSet insert or delete.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It records a policy and does not discard or reuse a computation; a generation captured earlier gives up its watchers at its next delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The host supplies its actual polling choice rather than this operation
+ *   inferring mount reliability from OS names or path prefixes. Consumers
+ *   separately qualify native backend capabilities; clearing polling permits
+ *   notification admission but does not establish trustworthy silence.
+ */
+export declare function declareTtscTransformPolling(cache: TtscTransformCache, polling: boolean): void;

package/lib/core/transform/cache/declareTtscTransformPolling.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var TRANSFORM_CACHE_POLLING = require('./TRANSFORM_CACHE_POLLING.js');
+
+/**
+ * Record whether the host that owns `cache` watches by polling.
+ *
+ * Called whenever the host's configuration resolves, since a plugin instance
+ * can be reused across servers with different watch options. A generation the
+ * cache captures afterwards opens no retained watcher under polling. One
+ * captured before, with native watchers, gives them up when the next delivery
+ * examines that retained generation and is proven from its recorded state
+ * instead (samchon/ttsc#1542). This policy update does not itself close
+ * handles.
+ *
+ * @param cache The persistent transform cache.
+ * @param polling Whether the host polls, typically from `hostDeclaresPolling`.
+ * @evidence contracts/common.md#principled-implementation Polling declaration is updated per resolved host configuration, so a reused plugin instance cannot retain an earlier server's notification assumption.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-keyed WeakSet records the policy; generation creation and withdrawal own watcher changes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Polling requires recorded-state validation rather than treating absent native events as freshness proof.
+ * @evidence contracts/common.md#meaningful-documentation The prose describes both newly captured and already retained generations under a changed host watch policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A cache owns at most one weak polling membership, inserted on true and
+ *   removed on false; it does not retain the cache. Generation owners acquire
+ *   or withdraw native handles when they consume this policy, not here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A WeakSet insert or delete.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It records a policy and does not discard or reuse a computation; a generation captured earlier gives up its watchers at its next delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The host supplies its actual polling choice rather than this operation
+ *   inferring mount reliability from OS names or path prefixes. Consumers
+ *   separately qualify native backend capabilities; clearing polling permits
+ *   notification admission but does not establish trustworthy silence.
+ */
+function declareTtscTransformPolling(cache, polling) {
+    if (polling)
+        TRANSFORM_CACHE_POLLING.TRANSFORM_CACHE_POLLING.add(cache);
+    else
+        TRANSFORM_CACHE_POLLING.TRANSFORM_CACHE_POLLING.delete(cache);
+}
+
+exports.declareTtscTransformPolling = declareTtscTransformPolling;
+//# sourceMappingURL=declareTtscTransformPolling.js.map

package/lib/core/transform/cache/declareTtscTransformPolling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declareTtscTransformPolling.js","sources":["../../../../src/core/transform/cache/declareTtscTransformPolling.ts"],"sourcesContent":[null],"names":["TRANSFORM_CACHE_POLLING"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,2BAA2B,CACzC,KAAyB,EACzB,OAAgB,EAAA;AAEhB,IAAA,IAAI,OAAO;AAAE,QAAAA,+CAAuB,CAAC,GAAG,CAAC,KAAK,CAAC;;AAC1C,QAAAA,+CAAuB,CAAC,MAAM,CAAC,KAAK,CAAC;AAC5C;;;;"}

package/lib/core/transform/cache/declareTtscTransformPolling.mjs

@@ -0,0 +1,40 @@
+import { TRANSFORM_CACHE_POLLING } from './TRANSFORM_CACHE_POLLING.mjs';
+
+/**
+ * Record whether the host that owns `cache` watches by polling.
+ *
+ * Called whenever the host's configuration resolves, since a plugin instance
+ * can be reused across servers with different watch options. A generation the
+ * cache captures afterwards opens no retained watcher under polling. One
+ * captured before, with native watchers, gives them up when the next delivery
+ * examines that retained generation and is proven from its recorded state
+ * instead (samchon/ttsc#1542). This policy update does not itself close
+ * handles.
+ *
+ * @param cache The persistent transform cache.
+ * @param polling Whether the host polls, typically from `hostDeclaresPolling`.
+ * @evidence contracts/common.md#principled-implementation Polling declaration is updated per resolved host configuration, so a reused plugin instance cannot retain an earlier server's notification assumption.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-keyed WeakSet records the policy; generation creation and withdrawal own watcher changes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Polling requires recorded-state validation rather than treating absent native events as freshness proof.
+ * @evidence contracts/common.md#meaningful-documentation The prose describes both newly captured and already retained generations under a changed host watch policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A cache owns at most one weak polling membership, inserted on true and
+ *   removed on false; it does not retain the cache. Generation owners acquire
+ *   or withdraw native handles when they consume this policy, not here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A WeakSet insert or delete.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work It records a policy and does not discard or reuse a computation; a generation captured earlier gives up its watchers at its next delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   The host supplies its actual polling choice rather than this operation
+ *   inferring mount reliability from OS names or path prefixes. Consumers
+ *   separately qualify native backend capabilities; clearing polling permits
+ *   notification admission but does not establish trustworthy silence.
+ */
+function declareTtscTransformPolling(cache, polling) {
+    if (polling)
+        TRANSFORM_CACHE_POLLING.add(cache);
+    else
+        TRANSFORM_CACHE_POLLING.delete(cache);
+}
+
+export { declareTtscTransformPolling };
+//# sourceMappingURL=declareTtscTransformPolling.mjs.map

package/lib/core/transform/cache/declareTtscTransformPolling.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"declareTtscTransformPolling.mjs","sources":["../../../../src/core/transform/cache/declareTtscTransformPolling.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,2BAA2B,CACzC,KAAyB,EACzB,OAAgB,EAAA;AAEhB,IAAA,IAAI,OAAO;AAAE,QAAA,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC;;AAC1C,QAAA,uBAAuB,CAAC,MAAM,CAAC,KAAK,CAAC;AAC5C;;;;"}

package/lib/core/transform/cache/disposeCachedTransform.d.cts

@@ -0,0 +1,25 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
+/**
+ * Detach one generation's watchers and attempt its owned probe cleanup.
+ *
+ * Each independent tracker is attempted after every field and the clock
+ * association are detached. Repeated disposal then has no retained handle to
+ * close. A failed native close/removal is tolerated, not certified as
+ * released.
+ *
+ * @evidence contracts/common.md#principled-implementation Removing handles from the generation before closing makes repeated disposal harmless; each independent tracker is attempted even if another close throws.
+ * @evidence contracts/common.md#clear-and-simple-design The disposer owns the three tracker fields and clock reference only, leaving cache membership and lifecycle scheduling to their callers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Catching a close failure preserves independent cleanup, without turning a failed compile or validation into a successful result.
+ * @evidence contracts/common.md#meaningful-documentation The native comment identifies generation ownership, and the internal explanation states why scheduled cleanup must not leave rejected promises.
+ * @evidence contracts/performance.md#efficient-algorithms Disposal visits three trackers and one clock reference; delegated tracker cleanup closes W retained watchers in O(W) work and temporary references, without rescanning project files.
+ * @evidence contracts/performance.md#reuse-equivalent-work One disposer handles eviction and complete reset, avoiding divergent lifetime rules.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Handles and the clock association detach before cleanup, and every
+ *   independent resource is attempted. Repeated disposal owns no remaining
+ *   handle; failed native close or owned probe/directory removal can leave an
+ *   underlying resource. No retry task or failure history is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral disposal invokes each native close capability and the shared owned-probe remover without assuming watchers or busy-file removal behave identically across OSes.
+ */
+export declare function disposeCachedTransform(
+/** Generation whose retained resource fields transfer to cleanup attempts. */
+cached: TtscCachedProjectTransform): void;