@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,40 @@
+import { hostDeclaresPolling } from '../tracker/hostDeclaresPolling.mjs';
+import { TRANSFORM_CACHE_POLLING } from './TRANSFORM_CACHE_POLLING.mjs';
+
+/**
+ * Whether polling policy permits a generation to acquire notification proof.
+ *
+ * Neither the host nor the process environment may have declared polling
+ * (samchon/ttsc#1395). Otherwise the generation opens no retained watcher and
+ * validates each delivery by metadata and content, the path a generation whose
+ * watcher failed already takes. True is permission, not unchanged-input
+ * evidence: coverage, directory identity, event classification and actual
+ * backend authority still qualify the generation's trackers.
+ *
+ * @evidence contracts/common.md#principled-implementation Notification trust requires a cache and no polling declaration from either the cache's host or process environment.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate combines the two policy owners; tracker capability and actual notification settlement remain separate proof requirements.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A false predicate selects real metadata/content proof rather than accepting silent watchers under polling.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the two polling declarations and the recorded-state path used when trust is unavailable.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Absent caches and declared cache polling short-circuit before environment
+ *   parsing. Otherwise the host parser reads two named values and may lowercase
+ *   Chokidar text or convert and compare Watchpack numeric text; work and
+ *   temporary strings scale with the supplied declaration lengths.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-evaluated per delivery because a host or the environment can change its polling declaration; nothing is shared.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Native notification admission follows the cache owner's polling declaration
+ *   and the existing host environment parser, not an OS or mount-name guess.
+ *   A positive policy result adds no capability or alias-free assumption;
+ *   actual tracker coverage and backend proof remain with their native owners.
+ */
+function transformCacheTrustsNotifications(
+/** Cache owning host polling policy, or absent when no tracker is retained. */
+cache) {
+    return (cache !== undefined &&
+        !TRANSFORM_CACHE_POLLING.has(cache) &&
+        !hostDeclaresPolling());
+}
+
+export { transformCacheTrustsNotifications };
+//# sourceMappingURL=transformCacheTrustsNotifications.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformCacheTrustsNotifications.mjs","sources":["../../../../src/core/transform/cache/transformCacheTrustsNotifications.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;SACa,iCAAiC;AAC/C;AACA,KAAqC,EAAA;IAErC,QACE,KAAK,KAAK,SAAS;AACnB,QAAA,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC;QACnC,CAAC,mBAAmB,EAAE;AAE1B;;;;"}

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

@@ -0,0 +1,26 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Return the filesystem view a delivery through `cache` must use.
+ *
+ * A cache created by `createTtscTransformCache` carries the operations it was
+ * created with, which may observe a filesystem other than the host's. A
+ * delivery without a cache, or through a cache created elsewhere, uses the host
+ * filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation Deliveries use the cache's declared filesystem operations; absent or unregistered caches use the actual host defaults.
+ * @evidence contracts/common.md#clear-and-simple-design One capability lookup selects the view without copying snapshots or adding another filesystem abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit view selection avoids foreign-method monkeypatching and preserves the distinction between injected and native observations.
+ * @evidence contracts/common.md#meaningful-documentation The native prose states both ownership by cache construction and the exact fallback cases.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the cache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup returns the operation table the cache was created with; there is no computation to share.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Capture and validation receive the cache's supplied read, native identity,
+ *   case/platform and optional watch capabilities unchanged. Missing cache
+ *   registration uses the Node host defaults; this selector does not infer
+ *   volume policy from an OS name or fabricate observations for either view.
+ */
+export declare function transformFilesystem(
+/** Cache registered with its observing view, or absent for native defaults. */
+cache: TtscTransformCache | undefined): TtscTransformFilesystemOperations;

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

@@ -0,0 +1,26 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Return the filesystem view a delivery through `cache` must use.
+ *
+ * A cache created by `createTtscTransformCache` carries the operations it was
+ * created with, which may observe a filesystem other than the host's. A
+ * delivery without a cache, or through a cache created elsewhere, uses the host
+ * filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation Deliveries use the cache's declared filesystem operations; absent or unregistered caches use the actual host defaults.
+ * @evidence contracts/common.md#clear-and-simple-design One capability lookup selects the view without copying snapshots or adding another filesystem abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit view selection avoids foreign-method monkeypatching and preserves the distinction between injected and native observations.
+ * @evidence contracts/common.md#meaningful-documentation The native prose states both ownership by cache construction and the exact fallback cases.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the cache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup returns the operation table the cache was created with; there is no computation to share.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Capture and validation receive the cache's supplied read, native identity,
+ *   case/platform and optional watch capabilities unchanged. Missing cache
+ *   registration uses the Node host defaults; this selector does not infer
+ *   volume policy from an OS name or fabricate observations for either view.
+ */
+export declare function transformFilesystem(
+/** Cache registered with its observing view, or absent for native defaults. */
+cache: TtscTransformCache | undefined): TtscTransformFilesystemOperations;

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

@@ -0,0 +1,26 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Return the filesystem view a delivery through `cache` must use.
+ *
+ * A cache created by `createTtscTransformCache` carries the operations it was
+ * created with, which may observe a filesystem other than the host's. A
+ * delivery without a cache, or through a cache created elsewhere, uses the host
+ * filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation Deliveries use the cache's declared filesystem operations; absent or unregistered caches use the actual host defaults.
+ * @evidence contracts/common.md#clear-and-simple-design One capability lookup selects the view without copying snapshots or adding another filesystem abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit view selection avoids foreign-method monkeypatching and preserves the distinction between injected and native observations.
+ * @evidence contracts/common.md#meaningful-documentation The native prose states both ownership by cache construction and the exact fallback cases.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the cache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup returns the operation table the cache was created with; there is no computation to share.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Capture and validation receive the cache's supplied read, native identity,
+ *   case/platform and optional watch capabilities unchanged. Missing cache
+ *   registration uses the Node host defaults; this selector does not infer
+ *   volume policy from an OS name or fabricate observations for either view.
+ */
+export declare function transformFilesystem(
+/** Cache registered with its observing view, or absent for native defaults. */
+cache: TtscTransformCache | undefined): TtscTransformFilesystemOperations;

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

@@ -0,0 +1,35 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var TRANSFORM_CACHE_FILESYSTEM = require('./TRANSFORM_CACHE_FILESYSTEM.js');
+
+/**
+ * Return the filesystem view a delivery through `cache` must use.
+ *
+ * A cache created by `createTtscTransformCache` carries the operations it was
+ * created with, which may observe a filesystem other than the host's. A
+ * delivery without a cache, or through a cache created elsewhere, uses the host
+ * filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation Deliveries use the cache's declared filesystem operations; absent or unregistered caches use the actual host defaults.
+ * @evidence contracts/common.md#clear-and-simple-design One capability lookup selects the view without copying snapshots or adding another filesystem abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit view selection avoids foreign-method monkeypatching and preserves the distinction between injected and native observations.
+ * @evidence contracts/common.md#meaningful-documentation The native prose states both ownership by cache construction and the exact fallback cases.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the cache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup returns the operation table the cache was created with; there is no computation to share.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Capture and validation receive the cache's supplied read, native identity,
+ *   case/platform and optional watch capabilities unchanged. Missing cache
+ *   registration uses the Node host defaults; this selector does not infer
+ *   volume policy from an OS name or fabricate observations for either view.
+ */
+function transformFilesystem(
+/** Cache registered with its observing view, or absent for native defaults. */
+cache) {
+    return ((cache === undefined ? undefined : TRANSFORM_CACHE_FILESYSTEM.TRANSFORM_CACHE_FILESYSTEM.get(cache)) ??
+        DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS);
+}
+
+exports.transformFilesystem = transformFilesystem;
+//# sourceMappingURL=transformFilesystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformFilesystem.js","sources":["../../../../src/core/transform/cache/transformFilesystem.ts"],"sourcesContent":[null],"names":["TRANSFORM_CACHE_FILESYSTEM","DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,mBAAmB;AACjC;AACA,KAAqC,EAAA;AAErC,IAAA,QACE,CAAC,KAAK,KAAK,SAAS,GAAG,SAAS,GAAGA,qDAA0B,CAAC,GAAG,CAAC,KAAK,CAAC;AACxE,QAAAC,2DAA6B;AAEjC;;;;"}

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

@@ -0,0 +1,33 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { TRANSFORM_CACHE_FILESYSTEM } from './TRANSFORM_CACHE_FILESYSTEM.mjs';
+
+/**
+ * Return the filesystem view a delivery through `cache` must use.
+ *
+ * A cache created by `createTtscTransformCache` carries the operations it was
+ * created with, which may observe a filesystem other than the host's. A
+ * delivery without a cache, or through a cache created elsewhere, uses the host
+ * filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation Deliveries use the cache's declared filesystem operations; absent or unregistered caches use the actual host defaults.
+ * @evidence contracts/common.md#clear-and-simple-design One capability lookup selects the view without copying snapshots or adding another filesystem abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit view selection avoids foreign-method monkeypatching and preserves the distinction between injected and native observations.
+ * @evidence contracts/common.md#meaningful-documentation The native prose states both ownership by cache construction and the exact fallback cases.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the cache.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup returns the operation table the cache was created with; there is no computation to share.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Capture and validation receive the cache's supplied read, native identity,
+ *   case/platform and optional watch capabilities unchanged. Missing cache
+ *   registration uses the Node host defaults; this selector does not infer
+ *   volume policy from an OS name or fabricate observations for either view.
+ */
+function transformFilesystem(
+/** Cache registered with its observing view, or absent for native defaults. */
+cache) {
+    return ((cache === undefined ? undefined : TRANSFORM_CACHE_FILESYSTEM.get(cache)) ??
+        DEFAULT_FILESYSTEM_OPERATIONS);
+}
+
+export { transformFilesystem };
+//# sourceMappingURL=transformFilesystem.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformFilesystem.mjs","sources":["../../../../src/core/transform/cache/transformFilesystem.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,mBAAmB;AACjC;AACA,KAAqC,EAAA;AAErC,IAAA,QACE,CAAC,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,0BAA0B,CAAC,GAAG,CAAC,KAAK,CAAC;AACxE,QAAA,6BAA6B;AAEjC;;;;"}

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

@@ -0,0 +1,23 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
+/**
+ * Detach a generation's retained watchers and attempt their closure.
+ *
+ * Validation lets a retained watcher's silence stand in for re-reading inputs.
+ * When the host's watch policy stops justifying that, trackers are detached
+ * before their close attempts, and later validation takes the path a generation
+ * whose watchers never opened already takes: its recorded snapshot. The clock
+ * reference and the generation itself stay, so an unchanged project keeps its
+ * compile.
+ *
+ * @evidence contracts/common.md#principled-implementation Detaching all tracker fields before closure removes their authority immediately, so subsequent validation cannot rely on a tracker whose cleanup failed.
+ * @evidence contracts/common.md#clear-and-simple-design Withdrawal closes notification resources while preserving the generation and clock evidence needed by recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Close failures cannot create freshness proof; every independent tracker is still attempted and retained output remains subject to snapshot validation.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains the authority transition, and the internal comment distinguishes cleanup failure from stale-output authorization.
+ * @evidence contracts/performance.md#efficient-algorithms Withdrawal checks at most three tracker fields and delegates each close's W retained-watch cleanup; it does not scan project files or start a compile. Fixed wrapper work does not make native closure duration constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation and clock evidence remain reusable under snapshot validation, so changed watch policy alone does not waste an equivalent compile.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources All tracker fields detach before independent close attempts; repeat withdrawal sees no retained handle. Failed closes can leave native resources without retaining freshness authority. Generation/clock ownership survives and this operation adds no retry task or history.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral policy changes close through the actual backend handles; unavailable notification authority requires recorded-state proof.
+ */
+export declare function withdrawGenerationNotifications(
+/** Generation keeping its snapshot/clock while giving up notification owners. */
+cached: TtscCachedProjectTransform): void;

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

@@ -0,0 +1,23 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.mjs";
+/**
+ * Detach a generation's retained watchers and attempt their closure.
+ *
+ * Validation lets a retained watcher's silence stand in for re-reading inputs.
+ * When the host's watch policy stops justifying that, trackers are detached
+ * before their close attempts, and later validation takes the path a generation
+ * whose watchers never opened already takes: its recorded snapshot. The clock
+ * reference and the generation itself stay, so an unchanged project keeps its
+ * compile.
+ *
+ * @evidence contracts/common.md#principled-implementation Detaching all tracker fields before closure removes their authority immediately, so subsequent validation cannot rely on a tracker whose cleanup failed.
+ * @evidence contracts/common.md#clear-and-simple-design Withdrawal closes notification resources while preserving the generation and clock evidence needed by recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Close failures cannot create freshness proof; every independent tracker is still attempted and retained output remains subject to snapshot validation.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains the authority transition, and the internal comment distinguishes cleanup failure from stale-output authorization.
+ * @evidence contracts/performance.md#efficient-algorithms Withdrawal checks at most three tracker fields and delegates each close's W retained-watch cleanup; it does not scan project files or start a compile. Fixed wrapper work does not make native closure duration constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation and clock evidence remain reusable under snapshot validation, so changed watch policy alone does not waste an equivalent compile.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources All tracker fields detach before independent close attempts; repeat withdrawal sees no retained handle. Failed closes can leave native resources without retaining freshness authority. Generation/clock ownership survives and this operation adds no retry task or history.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral policy changes close through the actual backend handles; unavailable notification authority requires recorded-state proof.
+ */
+export declare function withdrawGenerationNotifications(
+/** Generation keeping its snapshot/clock while giving up notification owners. */
+cached: TtscCachedProjectTransform): void;

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

@@ -0,0 +1,23 @@
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
+/**
+ * Detach a generation's retained watchers and attempt their closure.
+ *
+ * Validation lets a retained watcher's silence stand in for re-reading inputs.
+ * When the host's watch policy stops justifying that, trackers are detached
+ * before their close attempts, and later validation takes the path a generation
+ * whose watchers never opened already takes: its recorded snapshot. The clock
+ * reference and the generation itself stay, so an unchanged project keeps its
+ * compile.
+ *
+ * @evidence contracts/common.md#principled-implementation Detaching all tracker fields before closure removes their authority immediately, so subsequent validation cannot rely on a tracker whose cleanup failed.
+ * @evidence contracts/common.md#clear-and-simple-design Withdrawal closes notification resources while preserving the generation and clock evidence needed by recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Close failures cannot create freshness proof; every independent tracker is still attempted and retained output remains subject to snapshot validation.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains the authority transition, and the internal comment distinguishes cleanup failure from stale-output authorization.
+ * @evidence contracts/performance.md#efficient-algorithms Withdrawal checks at most three tracker fields and delegates each close's W retained-watch cleanup; it does not scan project files or start a compile. Fixed wrapper work does not make native closure duration constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation and clock evidence remain reusable under snapshot validation, so changed watch policy alone does not waste an equivalent compile.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources All tracker fields detach before independent close attempts; repeat withdrawal sees no retained handle. Failed closes can leave native resources without retaining freshness authority. Generation/clock ownership survives and this operation adds no retry task or history.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral policy changes close through the actual backend handles; unavailable notification authority requires recorded-state proof.
+ */
+export declare function withdrawGenerationNotifications(
+/** Generation keeping its snapshot/clock while giving up notification owners. */
+cached: TtscCachedProjectTransform): void;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * Detach a generation's retained watchers and attempt their closure.
+ *
+ * Validation lets a retained watcher's silence stand in for re-reading inputs.
+ * When the host's watch policy stops justifying that, trackers are detached
+ * before their close attempts, and later validation takes the path a generation
+ * whose watchers never opened already takes: its recorded snapshot. The clock
+ * reference and the generation itself stay, so an unchanged project keeps its
+ * compile.
+ *
+ * @evidence contracts/common.md#principled-implementation Detaching all tracker fields before closure removes their authority immediately, so subsequent validation cannot rely on a tracker whose cleanup failed.
+ * @evidence contracts/common.md#clear-and-simple-design Withdrawal closes notification resources while preserving the generation and clock evidence needed by recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Close failures cannot create freshness proof; every independent tracker is still attempted and retained output remains subject to snapshot validation.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains the authority transition, and the internal comment distinguishes cleanup failure from stale-output authorization.
+ * @evidence contracts/performance.md#efficient-algorithms Withdrawal checks at most three tracker fields and delegates each close's W retained-watch cleanup; it does not scan project files or start a compile. Fixed wrapper work does not make native closure duration constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation and clock evidence remain reusable under snapshot validation, so changed watch policy alone does not waste an equivalent compile.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources All tracker fields detach before independent close attempts; repeat withdrawal sees no retained handle. Failed closes can leave native resources without retaining freshness authority. Generation/clock ownership survives and this operation adds no retry task or history.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral policy changes close through the actual backend handles; unavailable notification authority requires recorded-state proof.
+ */
+function withdrawGenerationNotifications(
+/** Generation keeping its snapshot/clock while giving up notification owners. */
+cached) {
+    const trackers = [
+        cached.projectMutationTracker,
+        cached.hostInputMutationTracker,
+        cached.candidateMutationTracker,
+    ];
+    if (trackers.every((tracker) => tracker === undefined))
+        return;
+    cached.projectMutationTracker = undefined;
+    cached.hostInputMutationTracker = undefined;
+    cached.candidateMutationTracker = undefined;
+    for (const tracker of trackers) {
+        try {
+            tracker?.close();
+        }
+        catch {
+            // The generation no longer reads the tracker, so a close failure leaves
+            // nothing it could serve stale.
+        }
+    }
+}
+
+exports.withdrawGenerationNotifications = withdrawGenerationNotifications;
+//# sourceMappingURL=withdrawGenerationNotifications.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawGenerationNotifications.js","sources":["../../../../src/core/transform/cache/withdrawGenerationNotifications.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;AAkBG;SACa,+BAA+B;AAC7C;AACA,MAAkC,EAAA;AAElC,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;KAChC;AACD,IAAA,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,KAAK,OAAO,KAAK,SAAS,CAAC;QAAE;AACxD,IAAA,MAAM,CAAC,sBAAsB,GAAG,SAAS;AACzC,IAAA,MAAM,CAAC,wBAAwB,GAAG,SAAS;AAC3C,IAAA,MAAM,CAAC,wBAAwB,GAAG,SAAS;AAC3C,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;AAC9B,QAAA,IAAI;YACF,OAAO,EAAE,KAAK,EAAE;QAClB;AAAE,QAAA,MAAM;;;QAGR;IACF;AACF;;;;"}

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

@@ -0,0 +1,45 @@
+/**
+ * Detach a generation's retained watchers and attempt their closure.
+ *
+ * Validation lets a retained watcher's silence stand in for re-reading inputs.
+ * When the host's watch policy stops justifying that, trackers are detached
+ * before their close attempts, and later validation takes the path a generation
+ * whose watchers never opened already takes: its recorded snapshot. The clock
+ * reference and the generation itself stay, so an unchanged project keeps its
+ * compile.
+ *
+ * @evidence contracts/common.md#principled-implementation Detaching all tracker fields before closure removes their authority immediately, so subsequent validation cannot rely on a tracker whose cleanup failed.
+ * @evidence contracts/common.md#clear-and-simple-design Withdrawal closes notification resources while preserving the generation and clock evidence needed by recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Close failures cannot create freshness proof; every independent tracker is still attempted and retained output remains subject to snapshot validation.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains the authority transition, and the internal comment distinguishes cleanup failure from stale-output authorization.
+ * @evidence contracts/performance.md#efficient-algorithms Withdrawal checks at most three tracker fields and delegates each close's W retained-watch cleanup; it does not scan project files or start a compile. Fixed wrapper work does not make native closure duration constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation and clock evidence remain reusable under snapshot validation, so changed watch policy alone does not waste an equivalent compile.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources All tracker fields detach before independent close attempts; repeat withdrawal sees no retained handle. Failed closes can leave native resources without retaining freshness authority. Generation/clock ownership survives and this operation adds no retry task or history.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral policy changes close through the actual backend handles; unavailable notification authority requires recorded-state proof.
+ */
+function withdrawGenerationNotifications(
+/** Generation keeping its snapshot/clock while giving up notification owners. */
+cached) {
+    const trackers = [
+        cached.projectMutationTracker,
+        cached.hostInputMutationTracker,
+        cached.candidateMutationTracker,
+    ];
+    if (trackers.every((tracker) => tracker === undefined))
+        return;
+    cached.projectMutationTracker = undefined;
+    cached.hostInputMutationTracker = undefined;
+    cached.candidateMutationTracker = undefined;
+    for (const tracker of trackers) {
+        try {
+            tracker?.close();
+        }
+        catch {
+            // The generation no longer reads the tracker, so a close failure leaves
+            // nothing it could serve stale.
+        }
+    }
+}
+
+export { withdrawGenerationNotifications };
+//# sourceMappingURL=withdrawGenerationNotifications.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawGenerationNotifications.mjs","sources":["../../../../src/core/transform/cache/withdrawGenerationNotifications.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;AAkBG;SACa,+BAA+B;AAC7C;AACA,MAAkC,EAAA;AAElC,IAAA,MAAM,QAAQ,GAAG;AACf,QAAA,MAAM,CAAC,sBAAsB;AAC7B,QAAA,MAAM,CAAC,wBAAwB;AAC/B,QAAA,MAAM,CAAC,wBAAwB;KAChC;AACD,IAAA,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,KAAK,OAAO,KAAK,SAAS,CAAC;QAAE;AACxD,IAAA,MAAM,CAAC,sBAAsB,GAAG,SAAS;AACzC,IAAA,MAAM,CAAC,wBAAwB,GAAG,SAAS;AAC3C,IAAA,MAAM,CAAC,wBAAwB,GAAG,SAAS;AAC3C,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;AAC9B,QAAA,IAAI;YACF,OAAO,EAAE,KAAK,EAAE;QAClB;AAAE,QAAA,MAAM;;;QAGR;IACF;AACF;;;;"}

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

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Withdraw every generation while preserving the host's current delivery pass.
+ *
+ * Volatile input observations disqualify reuse without ending a one-shot build.
+ * Clear membership immediately; fulfilled pending generations subsequently
+ * attempt owned tracker/probe cleanup. No compilation is cancelled here.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation withdrawal clears only cached promises; the host's epoch stays authoritative until its actual terminal lifecycle boundary.
+ * @evidence contracts/common.md#clear-and-simple-design One operation shares generation disposal between volatile withdrawal and terminal reset without conflating their lifecycle authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Incomplete observation actually withdraws reusable entries; it does not invent a new pass or mark metadata that no owner consumes.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish immediate membership withdrawal, scheduled resource cleanup and the retained delivery pass, without promising successful native release.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   An O(N) promise snapshot is followed by one N-entry reaction scheduling
+ *   pass and membership clear, without serially awaiting compilation. Fulfilled
+ *   reactions additionally delegate each generation's watcher/probe cleanup;
+ *   snapshots and reactions require temporary population-sized storage.
+ * @evidence contracts/performance.md#reuse-equivalent-work Terminal reset and volatile withdrawal share the same generation disposal operation; complete ordinary pass opening retains its existing reuse policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Membership is cleared before attaching reactions. Each fulfilled withdrawn
+ *   promise transfers its generation to the disposer; rejection is consumed.
+ *   Pending reactions have no cancellation/settlement deadline, and failed
+ *   native cleanup can leave underlying resources despite detached ownership.
+ *   The delivery epoch is deliberately retained by its separate owner.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Fulfilled generation cleanup uses its actual supplied native tracker and
+ *   clock-probe owners, without platform-name assumptions about close/removal
+ *   success. This coordinator keeps configuration keys opaque and preserves
+ *   the caller's lifecycle boundary separately from native cleanup.
+ */
+export declare function withdrawTtscTransformGenerations(
+/** Cache whose generations are withdrawn while its delivery pass survives. */
+cache: TtscTransformCache): void;

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

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Withdraw every generation while preserving the host's current delivery pass.
+ *
+ * Volatile input observations disqualify reuse without ending a one-shot build.
+ * Clear membership immediately; fulfilled pending generations subsequently
+ * attempt owned tracker/probe cleanup. No compilation is cancelled here.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation withdrawal clears only cached promises; the host's epoch stays authoritative until its actual terminal lifecycle boundary.
+ * @evidence contracts/common.md#clear-and-simple-design One operation shares generation disposal between volatile withdrawal and terminal reset without conflating their lifecycle authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Incomplete observation actually withdraws reusable entries; it does not invent a new pass or mark metadata that no owner consumes.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish immediate membership withdrawal, scheduled resource cleanup and the retained delivery pass, without promising successful native release.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   An O(N) promise snapshot is followed by one N-entry reaction scheduling
+ *   pass and membership clear, without serially awaiting compilation. Fulfilled
+ *   reactions additionally delegate each generation's watcher/probe cleanup;
+ *   snapshots and reactions require temporary population-sized storage.
+ * @evidence contracts/performance.md#reuse-equivalent-work Terminal reset and volatile withdrawal share the same generation disposal operation; complete ordinary pass opening retains its existing reuse policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Membership is cleared before attaching reactions. Each fulfilled withdrawn
+ *   promise transfers its generation to the disposer; rejection is consumed.
+ *   Pending reactions have no cancellation/settlement deadline, and failed
+ *   native cleanup can leave underlying resources despite detached ownership.
+ *   The delivery epoch is deliberately retained by its separate owner.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Fulfilled generation cleanup uses its actual supplied native tracker and
+ *   clock-probe owners, without platform-name assumptions about close/removal
+ *   success. This coordinator keeps configuration keys opaque and preserves
+ *   the caller's lifecycle boundary separately from native cleanup.
+ */
+export declare function withdrawTtscTransformGenerations(
+/** Cache whose generations are withdrawn while its delivery pass survives. */
+cache: TtscTransformCache): void;

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

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Withdraw every generation while preserving the host's current delivery pass.
+ *
+ * Volatile input observations disqualify reuse without ending a one-shot build.
+ * Clear membership immediately; fulfilled pending generations subsequently
+ * attempt owned tracker/probe cleanup. No compilation is cancelled here.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation withdrawal clears only cached promises; the host's epoch stays authoritative until its actual terminal lifecycle boundary.
+ * @evidence contracts/common.md#clear-and-simple-design One operation shares generation disposal between volatile withdrawal and terminal reset without conflating their lifecycle authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Incomplete observation actually withdraws reusable entries; it does not invent a new pass or mark metadata that no owner consumes.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish immediate membership withdrawal, scheduled resource cleanup and the retained delivery pass, without promising successful native release.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   An O(N) promise snapshot is followed by one N-entry reaction scheduling
+ *   pass and membership clear, without serially awaiting compilation. Fulfilled
+ *   reactions additionally delegate each generation's watcher/probe cleanup;
+ *   snapshots and reactions require temporary population-sized storage.
+ * @evidence contracts/performance.md#reuse-equivalent-work Terminal reset and volatile withdrawal share the same generation disposal operation; complete ordinary pass opening retains its existing reuse policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Membership is cleared before attaching reactions. Each fulfilled withdrawn
+ *   promise transfers its generation to the disposer; rejection is consumed.
+ *   Pending reactions have no cancellation/settlement deadline, and failed
+ *   native cleanup can leave underlying resources despite detached ownership.
+ *   The delivery epoch is deliberately retained by its separate owner.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Fulfilled generation cleanup uses its actual supplied native tracker and
+ *   clock-probe owners, without platform-name assumptions about close/removal
+ *   success. This coordinator keeps configuration keys opaque and preserves
+ *   the caller's lifecycle boundary separately from native cleanup.
+ */
+export declare function withdrawTtscTransformGenerations(
+/** Cache whose generations are withdrawn while its delivery pass survives. */
+cache: TtscTransformCache): void;

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

@@ -0,0 +1,45 @@
+'use strict';
+
+var disposeCachedTransform = require('./disposeCachedTransform.js');
+
+/**
+ * Withdraw every generation while preserving the host's current delivery pass.
+ *
+ * Volatile input observations disqualify reuse without ending a one-shot build.
+ * Clear membership immediately; fulfilled pending generations subsequently
+ * attempt owned tracker/probe cleanup. No compilation is cancelled here.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation withdrawal clears only cached promises; the host's epoch stays authoritative until its actual terminal lifecycle boundary.
+ * @evidence contracts/common.md#clear-and-simple-design One operation shares generation disposal between volatile withdrawal and terminal reset without conflating their lifecycle authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Incomplete observation actually withdraws reusable entries; it does not invent a new pass or mark metadata that no owner consumes.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish immediate membership withdrawal, scheduled resource cleanup and the retained delivery pass, without promising successful native release.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   An O(N) promise snapshot is followed by one N-entry reaction scheduling
+ *   pass and membership clear, without serially awaiting compilation. Fulfilled
+ *   reactions additionally delegate each generation's watcher/probe cleanup;
+ *   snapshots and reactions require temporary population-sized storage.
+ * @evidence contracts/performance.md#reuse-equivalent-work Terminal reset and volatile withdrawal share the same generation disposal operation; complete ordinary pass opening retains its existing reuse policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Membership is cleared before attaching reactions. Each fulfilled withdrawn
+ *   promise transfers its generation to the disposer; rejection is consumed.
+ *   Pending reactions have no cancellation/settlement deadline, and failed
+ *   native cleanup can leave underlying resources despite detached ownership.
+ *   The delivery epoch is deliberately retained by its separate owner.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Fulfilled generation cleanup uses its actual supplied native tracker and
+ *   clock-probe owners, without platform-name assumptions about close/removal
+ *   success. This coordinator keeps configuration keys opaque and preserves
+ *   the caller's lifecycle boundary separately from native cleanup.
+ */
+function withdrawTtscTransformGenerations(
+/** Cache whose generations are withdrawn while its delivery pass survives. */
+cache) {
+    const generations = [...cache.values()];
+    cache.clear();
+    for (const generation of generations) {
+        void generation.then(disposeCachedTransform.disposeCachedTransform, () => undefined);
+    }
+}
+
+exports.withdrawTtscTransformGenerations = withdrawTtscTransformGenerations;
+//# sourceMappingURL=withdrawTtscTransformGenerations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawTtscTransformGenerations.js","sources":["../../../../src/core/transform/cache/withdrawTtscTransformGenerations.ts"],"sourcesContent":[null],"names":["disposeCachedTransform"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,gCAAgC;AAC9C;AACA,KAAyB,EAAA;IAEzB,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;IACvC,KAAK,CAAC,KAAK,EAAE;AACb,IAAA,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;QACpC,KAAK,UAAU,CAAC,IAAI,CAACA,6CAAsB,EAAE,MAAM,SAAS,CAAC;IAC/D;AACF;;;;"}

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

@@ -0,0 +1,43 @@
+import { disposeCachedTransform } from './disposeCachedTransform.mjs';
+
+/**
+ * Withdraw every generation while preserving the host's current delivery pass.
+ *
+ * Volatile input observations disqualify reuse without ending a one-shot build.
+ * Clear membership immediately; fulfilled pending generations subsequently
+ * attempt owned tracker/probe cleanup. No compilation is cancelled here.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation withdrawal clears only cached promises; the host's epoch stays authoritative until its actual terminal lifecycle boundary.
+ * @evidence contracts/common.md#clear-and-simple-design One operation shares generation disposal between volatile withdrawal and terminal reset without conflating their lifecycle authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Incomplete observation actually withdraws reusable entries; it does not invent a new pass or mark metadata that no owner consumes.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish immediate membership withdrawal, scheduled resource cleanup and the retained delivery pass, without promising successful native release.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   An O(N) promise snapshot is followed by one N-entry reaction scheduling
+ *   pass and membership clear, without serially awaiting compilation. Fulfilled
+ *   reactions additionally delegate each generation's watcher/probe cleanup;
+ *   snapshots and reactions require temporary population-sized storage.
+ * @evidence contracts/performance.md#reuse-equivalent-work Terminal reset and volatile withdrawal share the same generation disposal operation; complete ordinary pass opening retains its existing reuse policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Membership is cleared before attaching reactions. Each fulfilled withdrawn
+ *   promise transfers its generation to the disposer; rejection is consumed.
+ *   Pending reactions have no cancellation/settlement deadline, and failed
+ *   native cleanup can leave underlying resources despite detached ownership.
+ *   The delivery epoch is deliberately retained by its separate owner.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Fulfilled generation cleanup uses its actual supplied native tracker and
+ *   clock-probe owners, without platform-name assumptions about close/removal
+ *   success. This coordinator keeps configuration keys opaque and preserves
+ *   the caller's lifecycle boundary separately from native cleanup.
+ */
+function withdrawTtscTransformGenerations(
+/** Cache whose generations are withdrawn while its delivery pass survives. */
+cache) {
+    const generations = [...cache.values()];
+    cache.clear();
+    for (const generation of generations) {
+        void generation.then(disposeCachedTransform, () => undefined);
+    }
+}
+
+export { withdrawTtscTransformGenerations };
+//# sourceMappingURL=withdrawTtscTransformGenerations.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawTtscTransformGenerations.mjs","sources":["../../../../src/core/transform/cache/withdrawTtscTransformGenerations.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,gCAAgC;AAC9C;AACA,KAAyB,EAAA;IAEzB,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;IACvC,KAAK,CAAC,KAAK,EAAE;AACb,IAAA,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;QACpC,KAAK,UAAU,CAAC,IAAI,CAAC,sBAAsB,EAAE,MAAM,SAAS,CAAC;IAC/D;AACF;;;;"}

package/lib/core/transform/clock/TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.d.cts

@@ -0,0 +1,3 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/** Internal retained clock-probe ownership for published generations. */
+export declare const TRANSFORM_CLOCK_REFERENCE_DIRECTORIES: WeakMap<TtscCachedProjectTransform, string>;

package/lib/core/transform/clock/TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.d.mts

@@ -0,0 +1,3 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/** Internal retained clock-probe ownership for published generations. */
+export declare const TRANSFORM_CLOCK_REFERENCE_DIRECTORIES: WeakMap<TtscCachedProjectTransform, string>;

package/lib/core/transform/clock/TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.d.ts

@@ -0,0 +1,3 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/** Internal retained clock-probe ownership for published generations. */
+export declare const TRANSFORM_CLOCK_REFERENCE_DIRECTORIES: WeakMap<TtscCachedProjectTransform, string>;