@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
+/**
+ * Keyed by the host-owned serialized configuration: native tsconfig identity
+ * and the JSON representations of compiler options, plugins and aliases.
+ * Ordered payloads are not recursively sorted by the key owner. The value is a
+ * `Promise` so concurrent transforms for the same project share a single
+ * in-flight compilation rather than spawning multiple `TtscCompiler`
+ * instances.
+ *
+ * @evidence contracts/common.md#principled-implementation A configuration key maps to the in-flight project promise, letting concurrent deliveries share the same compile and its recorded proof state.
+ * @evidence contracts/common.md#clear-and-simple-design The alias uses standard Map and Promise operations rather than an additional cache abstraction with independent state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A stored promise does not certify freshness; selection and validation owners must prove its generation before replay.
+ * @evidence contracts/common.md#meaningful-documentation The prose names the key dimensions and explains why promise-valued entries are necessary for concurrent deliveries.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This Map treats serialized configuration keys as opaque strings. Native
+ *   identity encoding belongs to createTransformCacheKey; filesystem views
+ *   and notification capabilities belong to the generation and its owners,
+ *   rather than a native address or backend field defined by this alias.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCache only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCache only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCache only declares a shape; it has no handle or retained
+ *   state at runtime.
+ */
+export type TtscTransformCache = Map<string, Promise<TtscCachedProjectTransform>>;

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.mjs";
+/**
+ * Keyed by the host-owned serialized configuration: native tsconfig identity
+ * and the JSON representations of compiler options, plugins and aliases.
+ * Ordered payloads are not recursively sorted by the key owner. The value is a
+ * `Promise` so concurrent transforms for the same project share a single
+ * in-flight compilation rather than spawning multiple `TtscCompiler`
+ * instances.
+ *
+ * @evidence contracts/common.md#principled-implementation A configuration key maps to the in-flight project promise, letting concurrent deliveries share the same compile and its recorded proof state.
+ * @evidence contracts/common.md#clear-and-simple-design The alias uses standard Map and Promise operations rather than an additional cache abstraction with independent state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A stored promise does not certify freshness; selection and validation owners must prove its generation before replay.
+ * @evidence contracts/common.md#meaningful-documentation The prose names the key dimensions and explains why promise-valued entries are necessary for concurrent deliveries.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This Map treats serialized configuration keys as opaque strings. Native
+ *   identity encoding belongs to createTransformCacheKey; filesystem views
+ *   and notification capabilities belong to the generation and its owners,
+ *   rather than a native address or backend field defined by this alias.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCache only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCache only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCache only declares a shape; it has no handle or retained
+ *   state at runtime.
+ */
+export type TtscTransformCache = Map<string, Promise<TtscCachedProjectTransform>>;

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
+/**
+ * Keyed by the host-owned serialized configuration: native tsconfig identity
+ * and the JSON representations of compiler options, plugins and aliases.
+ * Ordered payloads are not recursively sorted by the key owner. The value is a
+ * `Promise` so concurrent transforms for the same project share a single
+ * in-flight compilation rather than spawning multiple `TtscCompiler`
+ * instances.
+ *
+ * @evidence contracts/common.md#principled-implementation A configuration key maps to the in-flight project promise, letting concurrent deliveries share the same compile and its recorded proof state.
+ * @evidence contracts/common.md#clear-and-simple-design The alias uses standard Map and Promise operations rather than an additional cache abstraction with independent state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A stored promise does not certify freshness; selection and validation owners must prove its generation before replay.
+ * @evidence contracts/common.md#meaningful-documentation The prose names the key dimensions and explains why promise-valued entries are necessary for concurrent deliveries.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This Map treats serialized configuration keys as opaque strings. Native
+ *   identity encoding belongs to createTransformCacheKey; filesystem views
+ *   and notification capabilities belong to the generation and its owners,
+ *   rather than a native address or backend field defined by this alias.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCache only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCache only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCache only declares a shape; it has no handle or retained
+ *   state at runtime.
+ */
+export type TtscTransformCache = Map<string, Promise<TtscCachedProjectTransform>>;

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

@@ -0,0 +1,65 @@
+/**
+ * The lifetime of a build-scoped cache across the sessions that use it
+ * (samchon/ttsc#1396).
+ *
+ * @evidence contracts/common.md#principled-implementation Acquisition and release represent sessions sharing one build cache, whose generation may survive briefly between adjacent sessions.
+ * @evidence contracts/common.md#clear-and-simple-design Two lifecycle operations expose ownership without exposing the grace timer or resetting the cache from each consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A lease grants retention, not proof that retained output is fresh; each delivery pass still owns validation.
+ * @evidence contracts/common.md#meaningful-documentation The interface and method comments identify session ownership and the delayed final release.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   TtscTransformCacheLease only declares a shape; it has no filesystem, path
+ *   or process operation at runtime.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCacheLease only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCacheLease only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCacheLease only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscTransformCacheLease {
+    /**
+     * Start a session that uses the cache, cancelling a pending release.
+     *
+     * @evidence contracts/common.md#principled-implementation Acquisition declares one active session and prevents an earlier final-release timer from resetting its cache.
+     * @evidence contracts/common.md#clear-and-simple-design A synchronous lifecycle operation leaves the timer implementation with the lease owner.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Acquisition does not bypass generation validation or alter host lifecycle methods.
+     * @evidence contracts/common.md#meaningful-documentation The method comment states both ownership and cancellation effects needed by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of acquire is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     */
+    acquire(): void;
+    /**
+     * End a session; the last one schedules the cache's release.
+     *
+     * @evidence contracts/common.md#principled-implementation Release ends session ownership while retaining the generation only for the lease owner's bounded grace.
+     * @evidence contracts/common.md#clear-and-simple-design Consumers report their lifecycle boundary without managing another owner's cache or timer.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Release does not simulate a successful delivery or patch another compiler's shutdown.
+     * @evidence contracts/common.md#meaningful-documentation The comment explains why final release schedules cleanup rather than immediately discarding a shared generation.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of release is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     */
+    release(): void;
+}

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

@@ -0,0 +1,65 @@
+/**
+ * The lifetime of a build-scoped cache across the sessions that use it
+ * (samchon/ttsc#1396).
+ *
+ * @evidence contracts/common.md#principled-implementation Acquisition and release represent sessions sharing one build cache, whose generation may survive briefly between adjacent sessions.
+ * @evidence contracts/common.md#clear-and-simple-design Two lifecycle operations expose ownership without exposing the grace timer or resetting the cache from each consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A lease grants retention, not proof that retained output is fresh; each delivery pass still owns validation.
+ * @evidence contracts/common.md#meaningful-documentation The interface and method comments identify session ownership and the delayed final release.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   TtscTransformCacheLease only declares a shape; it has no filesystem, path
+ *   or process operation at runtime.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCacheLease only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCacheLease only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCacheLease only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscTransformCacheLease {
+    /**
+     * Start a session that uses the cache, cancelling a pending release.
+     *
+     * @evidence contracts/common.md#principled-implementation Acquisition declares one active session and prevents an earlier final-release timer from resetting its cache.
+     * @evidence contracts/common.md#clear-and-simple-design A synchronous lifecycle operation leaves the timer implementation with the lease owner.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Acquisition does not bypass generation validation or alter host lifecycle methods.
+     * @evidence contracts/common.md#meaningful-documentation The method comment states both ownership and cancellation effects needed by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of acquire is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     */
+    acquire(): void;
+    /**
+     * End a session; the last one schedules the cache's release.
+     *
+     * @evidence contracts/common.md#principled-implementation Release ends session ownership while retaining the generation only for the lease owner's bounded grace.
+     * @evidence contracts/common.md#clear-and-simple-design Consumers report their lifecycle boundary without managing another owner's cache or timer.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Release does not simulate a successful delivery or patch another compiler's shutdown.
+     * @evidence contracts/common.md#meaningful-documentation The comment explains why final release schedules cleanup rather than immediately discarding a shared generation.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of release is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     */
+    release(): void;
+}

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

@@ -0,0 +1,65 @@
+/**
+ * The lifetime of a build-scoped cache across the sessions that use it
+ * (samchon/ttsc#1396).
+ *
+ * @evidence contracts/common.md#principled-implementation Acquisition and release represent sessions sharing one build cache, whose generation may survive briefly between adjacent sessions.
+ * @evidence contracts/common.md#clear-and-simple-design Two lifecycle operations expose ownership without exposing the grace timer or resetting the cache from each consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A lease grants retention, not proof that retained output is fresh; each delivery pass still owns validation.
+ * @evidence contracts/common.md#meaningful-documentation The interface and method comments identify session ownership and the delayed final release.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   TtscTransformCacheLease only declares a shape; it has no filesystem, path
+ *   or process operation at runtime.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscTransformCacheLease only declares a shape; it has no computation at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscTransformCacheLease only declares a shape; it has no work to reuse at
+ *   runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscTransformCacheLease only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscTransformCacheLease {
+    /**
+     * Start a session that uses the cache, cancelling a pending release.
+     *
+     * @evidence contracts/common.md#principled-implementation Acquisition declares one active session and prevents an earlier final-release timer from resetting its cache.
+     * @evidence contracts/common.md#clear-and-simple-design A synchronous lifecycle operation leaves the timer implementation with the lease owner.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Acquisition does not bypass generation validation or alter host lifecycle methods.
+     * @evidence contracts/common.md#meaningful-documentation The method comment states both ownership and cancellation effects needed by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of acquire is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of acquire is declared here; the cost belongs to its
+     *   implementation.
+     */
+    acquire(): void;
+    /**
+     * End a session; the last one schedules the cache's release.
+     *
+     * @evidence contracts/common.md#principled-implementation Release ends session ownership while retaining the generation only for the lease owner's bounded grace.
+     * @evidence contracts/common.md#clear-and-simple-design Consumers report their lifecycle boundary without managing another owner's cache or timer.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Release does not simulate a successful delivery or patch another compiler's shutdown.
+     * @evidence contracts/common.md#meaningful-documentation The comment explains why final release schedules cleanup rather than immediately discarding a shared generation.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation
+     *   Only the signature of release is declared here; the platform behaviour
+     *   belongs to its implementation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+     *   Only the signature of release is declared here; the cost belongs to its
+     *   implementation.
+     */
+    release(): void;
+}

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

@@ -0,0 +1,37 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Await a cached generation, retaining only terminal proof failures.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Only a bounded unstable-generation error belonging to the current entry is retained; ordinary rejection evicts that entry and preserves the original error.
+ * @evidence contracts/common.md#clear-and-simple-design Awaiting and the rejection classification share one gate; eviction and terminal-baseline validation remain in their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retention avoids repeated identical failed work, but never converts the error into success or makes an ordinary transient rejection permanent.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains promise sharing and why terminal stabilization failure differs from a retryable host rejection.
+ * @evidence contracts/performance.md#efficient-algorithms Awaiting one shared promise and checking current entry identity avoids per-delivery recompilation and cache-wide failure scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Concurrent callers reuse one in-flight compile; unchanged bounded stabilization failure can replay while ordinary transient rejection remains retryable.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One terminal error is weakly associated with the current promise; its
+ *   validation data grows with the captured input/witness population, without
+ *   a byte bound supplied here. Other rejected promises are identity-evicted
+ *   and their rejections consumed; no fulfilled generation is present to
+ *   dispose on that rejection. Awaiting adds no cancellation/settlement deadline.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This gate classifies an already rejected promise by typed error and opaque
+ *   cache identity. It neither reads native inputs nor interprets the error's
+ *   captured paths/capabilities; terminal environment replay has that owner.
+ */
+export declare function awaitOrEvict(
+/** Cache permitting retention only while the supplied promise is current. */
+cache: TtscTransformCache | undefined, 
+/** Opaque configuration address for the identity check. */
+key: string, 
+/** Already-started compile shared with concurrent callers. */
+generation: Promise<TtscCachedProjectTransform>): Promise<TtscCachedProjectTransform>;

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

@@ -0,0 +1,37 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.mjs";
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Await a cached generation, retaining only terminal proof failures.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Only a bounded unstable-generation error belonging to the current entry is retained; ordinary rejection evicts that entry and preserves the original error.
+ * @evidence contracts/common.md#clear-and-simple-design Awaiting and the rejection classification share one gate; eviction and terminal-baseline validation remain in their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retention avoids repeated identical failed work, but never converts the error into success or makes an ordinary transient rejection permanent.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains promise sharing and why terminal stabilization failure differs from a retryable host rejection.
+ * @evidence contracts/performance.md#efficient-algorithms Awaiting one shared promise and checking current entry identity avoids per-delivery recompilation and cache-wide failure scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Concurrent callers reuse one in-flight compile; unchanged bounded stabilization failure can replay while ordinary transient rejection remains retryable.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One terminal error is weakly associated with the current promise; its
+ *   validation data grows with the captured input/witness population, without
+ *   a byte bound supplied here. Other rejected promises are identity-evicted
+ *   and their rejections consumed; no fulfilled generation is present to
+ *   dispose on that rejection. Awaiting adds no cancellation/settlement deadline.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This gate classifies an already rejected promise by typed error and opaque
+ *   cache identity. It neither reads native inputs nor interprets the error's
+ *   captured paths/capabilities; terminal environment replay has that owner.
+ */
+export declare function awaitOrEvict(
+/** Cache permitting retention only while the supplied promise is current. */
+cache: TtscTransformCache | undefined, 
+/** Opaque configuration address for the identity check. */
+key: string, 
+/** Already-started compile shared with concurrent callers. */
+generation: Promise<TtscCachedProjectTransform>): Promise<TtscCachedProjectTransform>;

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

@@ -0,0 +1,37 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Await a cached generation, retaining only terminal proof failures.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Only a bounded unstable-generation error belonging to the current entry is retained; ordinary rejection evicts that entry and preserves the original error.
+ * @evidence contracts/common.md#clear-and-simple-design Awaiting and the rejection classification share one gate; eviction and terminal-baseline validation remain in their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retention avoids repeated identical failed work, but never converts the error into success or makes an ordinary transient rejection permanent.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains promise sharing and why terminal stabilization failure differs from a retryable host rejection.
+ * @evidence contracts/performance.md#efficient-algorithms Awaiting one shared promise and checking current entry identity avoids per-delivery recompilation and cache-wide failure scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Concurrent callers reuse one in-flight compile; unchanged bounded stabilization failure can replay while ordinary transient rejection remains retryable.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One terminal error is weakly associated with the current promise; its
+ *   validation data grows with the captured input/witness population, without
+ *   a byte bound supplied here. Other rejected promises are identity-evicted
+ *   and their rejections consumed; no fulfilled generation is present to
+ *   dispose on that rejection. Awaiting adds no cancellation/settlement deadline.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This gate classifies an already rejected promise by typed error and opaque
+ *   cache identity. It neither reads native inputs nor interprets the error's
+ *   captured paths/capabilities; terminal environment replay has that owner.
+ */
+export declare function awaitOrEvict(
+/** Cache permitting retention only while the supplied promise is current. */
+cache: TtscTransformCache | undefined, 
+/** Opaque configuration address for the identity check. */
+key: string, 
+/** Already-started compile shared with concurrent callers. */
+generation: Promise<TtscCachedProjectTransform>): Promise<TtscCachedProjectTransform>;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+var TtscUnstableGenerationError = require('../errors/TtscUnstableGenerationError.js');
+var TERMINAL_TRANSFORM_GENERATIONS = require('./TERMINAL_TRANSFORM_GENERATIONS.js');
+var evictGeneration = require('./evictGeneration.js');
+
+/**
+ * Await a cached generation, retaining only terminal proof failures.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Only a bounded unstable-generation error belonging to the current entry is retained; ordinary rejection evicts that entry and preserves the original error.
+ * @evidence contracts/common.md#clear-and-simple-design Awaiting and the rejection classification share one gate; eviction and terminal-baseline validation remain in their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retention avoids repeated identical failed work, but never converts the error into success or makes an ordinary transient rejection permanent.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains promise sharing and why terminal stabilization failure differs from a retryable host rejection.
+ * @evidence contracts/performance.md#efficient-algorithms Awaiting one shared promise and checking current entry identity avoids per-delivery recompilation and cache-wide failure scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Concurrent callers reuse one in-flight compile; unchanged bounded stabilization failure can replay while ordinary transient rejection remains retryable.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One terminal error is weakly associated with the current promise; its
+ *   validation data grows with the captured input/witness population, without
+ *   a byte bound supplied here. Other rejected promises are identity-evicted
+ *   and their rejections consumed; no fulfilled generation is present to
+ *   dispose on that rejection. Awaiting adds no cancellation/settlement deadline.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This gate classifies an already rejected promise by typed error and opaque
+ *   cache identity. It neither reads native inputs nor interprets the error's
+ *   captured paths/capabilities; terminal environment replay has that owner.
+ */
+async function awaitOrEvict(
+/** Cache permitting retention only while the supplied promise is current. */
+cache, 
+/** Opaque configuration address for the identity check. */
+key, 
+/** Already-started compile shared with concurrent callers. */
+generation) {
+    try {
+        return await generation;
+    }
+    catch (error) {
+        if (error instanceof TtscUnstableGenerationError.TtscUnstableGenerationError &&
+            cache?.get(key) === generation) {
+            TERMINAL_TRANSFORM_GENERATIONS.TERMINAL_TRANSFORM_GENERATIONS.set(generation, error);
+        }
+        else {
+            evictGeneration.evictGeneration(cache, key, generation);
+        }
+        throw error;
+    }
+}
+
+exports.awaitOrEvict = awaitOrEvict;
+//# sourceMappingURL=awaitOrEvict.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"awaitOrEvict.js","sources":["../../../../src/core/transform/cache/awaitOrEvict.ts"],"sourcesContent":[null],"names":["TtscUnstableGenerationError","TERMINAL_TRANSFORM_GENERATIONS","evictGeneration"],"mappings":";;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,eAAe,YAAY;AAChC;AACA,KAAqC;AACrC;AACA,GAAW;AACX;AACA,UAA+C,EAAA;AAE/C,IAAA,IAAI;QACF,OAAO,MAAM,UAAU;IACzB;IAAE,OAAO,KAAK,EAAE;QACd,IACE,KAAK,YAAYA,uDAA2B;YAC5C,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,KAAK,UAAU,EAC9B;AACA,YAAAC,6DAA8B,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC;QACvD;aAAO;AACL,YAAAC,+BAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;QACzC;AACA,QAAA,MAAM,KAAK;IACb;AACF;;;;"}

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

@@ -0,0 +1,56 @@
+import { TtscUnstableGenerationError } from '../errors/TtscUnstableGenerationError.mjs';
+import { TERMINAL_TRANSFORM_GENERATIONS } from './TERMINAL_TRANSFORM_GENERATIONS.mjs';
+import { evictGeneration } from './evictGeneration.mjs';
+
+/**
+ * Await a cached generation, retaining only terminal proof failures.
+ *
+ * The cache stores the in-flight transform Promise before it settles so
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
+ *
+ * @evidence contracts/common.md#principled-implementation Only a bounded unstable-generation error belonging to the current entry is retained; ordinary rejection evicts that entry and preserves the original error.
+ * @evidence contracts/common.md#clear-and-simple-design Awaiting and the rejection classification share one gate; eviction and terminal-baseline validation remain in their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retention avoids repeated identical failed work, but never converts the error into success or makes an ordinary transient rejection permanent.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains promise sharing and why terminal stabilization failure differs from a retryable host rejection.
+ * @evidence contracts/performance.md#efficient-algorithms Awaiting one shared promise and checking current entry identity avoids per-delivery recompilation and cache-wide failure scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Concurrent callers reuse one in-flight compile; unchanged bounded stabilization failure can replay while ordinary transient rejection remains retryable.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One terminal error is weakly associated with the current promise; its
+ *   validation data grows with the captured input/witness population, without
+ *   a byte bound supplied here. Other rejected promises are identity-evicted
+ *   and their rejections consumed; no fulfilled generation is present to
+ *   dispose on that rejection. Awaiting adds no cancellation/settlement deadline.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   This gate classifies an already rejected promise by typed error and opaque
+ *   cache identity. It neither reads native inputs nor interprets the error's
+ *   captured paths/capabilities; terminal environment replay has that owner.
+ */
+async function awaitOrEvict(
+/** Cache permitting retention only while the supplied promise is current. */
+cache, 
+/** Opaque configuration address for the identity check. */
+key, 
+/** Already-started compile shared with concurrent callers. */
+generation) {
+    try {
+        return await generation;
+    }
+    catch (error) {
+        if (error instanceof TtscUnstableGenerationError &&
+            cache?.get(key) === generation) {
+            TERMINAL_TRANSFORM_GENERATIONS.set(generation, error);
+        }
+        else {
+            evictGeneration(cache, key, generation);
+        }
+        throw error;
+    }
+}
+
+export { awaitOrEvict };
+//# sourceMappingURL=awaitOrEvict.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"awaitOrEvict.mjs","sources":["../../../../src/core/transform/cache/awaitOrEvict.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,eAAe,YAAY;AAChC;AACA,KAAqC;AACrC;AACA,GAAW;AACX;AACA,UAA+C,EAAA;AAE/C,IAAA,IAAI;QACF,OAAO,MAAM,UAAU;IACzB;IAAE,OAAO,KAAK,EAAE;QACd,IACE,KAAK,YAAY,2BAA2B;YAC5C,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,KAAK,UAAU,EAC9B;AACA,YAAA,8BAA8B,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC;QACvD;aAAO;AACL,YAAA,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;QACzC;AACA,QAAA,MAAM,KAAK;IACb;AACF;;;;"}

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

@@ -0,0 +1,35 @@
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Open a delivery pass that can share a retained generation's complete proof.
+ *
+ * The counter update is fixed work. The pass's first delivery still proves the
+ * recorded snapshot; later first deliveries reaching source comparison hash
+ * their text and may compare disk bytes before sharing that proof. Repeated
+ * module deliveries retain their existing validation path.
+ *
+ * This deliberately retains the cached generation. The pass boundary is a
+ * statement about _deliveries_ — each module is requested at most once inside
+ * it — not about whether the compiled program is still correct, which the
+ * generation's own recorded snapshot answers and which `matchesCachedSource`
+ * proves once at the pass's first delivery. Clearing here instead made a host
+ * whose `buildStart` repeats recompile the whole project on every rebuild even
+ * when no compiler input had changed (samchon/ttsc#1300). Use
+ * `resetTtscTransformCache` to actually discard a generation and its watchers.
+ *
+ * Hosts without a guaranteed pass boundary use persistent validation unless
+ * they have another immutable lifecycle. Bun runtime setup, for example,
+ * defines one process-scoped module-loading session.
+ *
+ * @evidence contracts/common.md#principled-implementation Advancing the delivery epoch opens a new proof window without discarding the compiled generation, whose first delivery must still prove its snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-owned counter declares the pass; validation and disposal remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A pass boundary does not fabricate freshness or clear valid work to hide an invalidation error.
+ * @evidence contracts/common.md#meaningful-documentation The paragraphs distinguish delivery epochs from generation validity and identify hosts that lack a guaranteed pass boundary.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The epoch is one number per cache in a WeakMap and is released with the cache; the generations' own resources are released by resetTtscTransformCache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One counter increment.
+ * @evidence contracts/performance.md#reuse-equivalent-work Advancing the epoch instead of discarding the generation is what lets a repeating buildStart reuse its compile after the pass's first delivery proves it.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+export declare function beginTtscTransformBuild(
+/** Cache whose next deliveries belong to a newly declared host pass. */
+cache: TtscTransformCache): void;

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

@@ -0,0 +1,35 @@
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Open a delivery pass that can share a retained generation's complete proof.
+ *
+ * The counter update is fixed work. The pass's first delivery still proves the
+ * recorded snapshot; later first deliveries reaching source comparison hash
+ * their text and may compare disk bytes before sharing that proof. Repeated
+ * module deliveries retain their existing validation path.
+ *
+ * This deliberately retains the cached generation. The pass boundary is a
+ * statement about _deliveries_ — each module is requested at most once inside
+ * it — not about whether the compiled program is still correct, which the
+ * generation's own recorded snapshot answers and which `matchesCachedSource`
+ * proves once at the pass's first delivery. Clearing here instead made a host
+ * whose `buildStart` repeats recompile the whole project on every rebuild even
+ * when no compiler input had changed (samchon/ttsc#1300). Use
+ * `resetTtscTransformCache` to actually discard a generation and its watchers.
+ *
+ * Hosts without a guaranteed pass boundary use persistent validation unless
+ * they have another immutable lifecycle. Bun runtime setup, for example,
+ * defines one process-scoped module-loading session.
+ *
+ * @evidence contracts/common.md#principled-implementation Advancing the delivery epoch opens a new proof window without discarding the compiled generation, whose first delivery must still prove its snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One cache-owned counter declares the pass; validation and disposal remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A pass boundary does not fabricate freshness or clear valid work to hide an invalidation error.
+ * @evidence contracts/common.md#meaningful-documentation The paragraphs distinguish delivery epochs from generation validity and identify hosts that lack a guaranteed pass boundary.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The epoch is one number per cache in a WeakMap and is released with the cache; the generations' own resources are released by resetTtscTransformCache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One counter increment.
+ * @evidence contracts/performance.md#reuse-equivalent-work Advancing the epoch instead of discarding the generation is what lets a repeating buildStart reuse its compile after the pass's first delivery proves it.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+export declare function beginTtscTransformBuild(
+/** Cache whose next deliveries belong to a newly declared host pass. */
+cache: TtscTransformCache): void;