@ttsc/unplugin 0.31.5 → 0.32.1

package/lib/core/transform/TtscPrecompilation.d.ts

@@ -0,0 +1,52 @@
+import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions";
+import type { TtscTransformCache } from "./cache/TtscTransformCache";
+/**
+ * Schedule explicitly selected source entries before the host reaches their
+ * imports. Compilation and proof stay with the ordinary transform core.
+ *
+ * A host often discovers its next workspace project only after the preceding
+ * project's transform finishes (#1764). Starting known entries together avoids
+ * that dependency on host traversal order. Walking unrelated projects would
+ * execute plugins the user never selected, so this owner uses only the supplied
+ * entries. Preparation leaves module delivery and host registration to the
+ * actual request.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit entries authorize scheduling; the supplied core capture retains project selection, configuration identity and all generation proofs. The context contains the current working directory, options, aliases and delivery epoch, not new cache authority.
+ * @evidence contracts/common.md#clear-and-simple-design One scheduler owns per-cache startup deduplication and reset; the transform core owns compiled generations and their disposal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No directory-wide discovery, plugin substitution or skipped proof is introduced; preparation never impersonates a host module delivery.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains host traversal order, explicit effectful selection and separation from delivery; members state context lifetime and failure ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries resolve through native path semantics from the current cwd and read through the cache's filesystem boundary; source eligibility uses the adapter's existing shared predicate.
+ * @evidence contracts/performance.md#efficient-algorithms Each new context serializes cwd, options and aliases, then resolves and deduplicates E entries and reads their source bytes once. Capture starts without waiting for other entries; native capture and proof retain their own costs. Repeated requests serialize the context but do not reread the entries.
+ * @evidence contracts/performance.md#reuse-equivalent-work One latest context per cache and epoch starts each entry once; ordinary project keys deduplicate entries in the same project. Context equality controls scheduling only, and retained results still need normal admission.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources A WeakMap retains one context string per live cache. Startup rejection handlers consume each detached promise; running captures and native resources remain cache-owned and withdrawal disposes their fulfilled generations. No cancellation deadline or entry-count cap is added.
+ */
+export declare namespace TtscPrecompilation {
+    /**
+     * Start every eligible explicit entry without waiting for its siblings.
+     * Failed speculative preparation is reported when its module is requested, so
+     * an unrelated delivered project's load can proceed.
+     *
+     * @evidence contracts/common.md#principled-implementation The context is installed before captures start, so recursive and concurrent deliveries cannot restart the same batch; only supported source entries reach normal core capture.
+     * @evidence contracts/common.md#clear-and-simple-design One synchronous loop separates startup ownership from asynchronous capture settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed entry reads are not fabricated as empty source, and rejected captures do not become successful output. Actual delivery remains the error boundary.
+     * @evidence contracts/common.md#meaningful-documentation Prose states parallel startup and deferred error reporting; callback and context ownership remain explicit.
+     * @evidence contracts/portability.md#os-neutral-implementation Native absolute entry paths are passed as exact paths to capture and source reads use the same cache-owned filesystem as generation validation.
+     * @evidence contracts/performance.md#efficient-algorithms Context serialization precedes one E-entry deduplicating loop and actual source-byte reads; captures overlap their asynchronous work rather than being awaited sequentially.
+     * @evidence contracts/performance.md#reuse-equivalent-work Identical latest cwd, options, aliases and epoch skip scheduling; project Promise identity and normal input proof decide compile reuse, independently of this scheduling record.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Context state follows its weak cache key. Every started capture receives a rejection handler immediately; its own core/cache owners release native resources, including withdrawal during capture.
+     */
+    function start(cache: TtscTransformCache, options: ResolvedTtscUnpluginOptions, aliasPaths: Record<string, string[]> | undefined, capture: (file: string, source: string) => Promise<unknown>): void;
+    /**
+     * End startup ownership when the cache withdraws its generations.
+     *
+     * @evidence contracts/common.md#principled-implementation Withdrawal removes scheduling state with generation ownership so a later lifecycle can prepare the same entries again.
+     * @evidence contracts/common.md#clear-and-simple-design One weak-key deletion shares the cache's existing reset boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Clearing scheduling permission does not admit or cancel any compiled result.
+     * @evidence contracts/common.md#meaningful-documentation The headline identifies the same generation withdrawal boundary used by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation WeakMap deletion performs no native operation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms One identity deletion chooses no traversal or processing strategy.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation withdraws the previous scheduling record rather than reusing work.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Deletion releases the single scheduling record; native resources remain owned by generation withdrawal.
+     */
+    function clear(cache: TtscTransformCache): void;
+}

package/lib/core/transform/TtscPrecompilation.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var path = require('node:path');
+var isTransformTarget = require('../isTransformTarget.js');
+var transformCacheEpoch = require('./cache/transformCacheEpoch.js');
+var transformFilesystem = require('./cache/transformFilesystem.js');
+var pluginsAreDisabled = require('./utils/pluginsAreDisabled.js');
+
+/**
+ * Schedule explicitly selected source entries before the host reaches their
+ * imports. Compilation and proof stay with the ordinary transform core.
+ *
+ * A host often discovers its next workspace project only after the preceding
+ * project's transform finishes (#1764). Starting known entries together avoids
+ * that dependency on host traversal order. Walking unrelated projects would
+ * execute plugins the user never selected, so this owner uses only the supplied
+ * entries. Preparation leaves module delivery and host registration to the
+ * actual request.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit entries authorize scheduling; the supplied core capture retains project selection, configuration identity and all generation proofs. The context contains the current working directory, options, aliases and delivery epoch, not new cache authority.
+ * @evidence contracts/common.md#clear-and-simple-design One scheduler owns per-cache startup deduplication and reset; the transform core owns compiled generations and their disposal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No directory-wide discovery, plugin substitution or skipped proof is introduced; preparation never impersonates a host module delivery.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains host traversal order, explicit effectful selection and separation from delivery; members state context lifetime and failure ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries resolve through native path semantics from the current cwd and read through the cache's filesystem boundary; source eligibility uses the adapter's existing shared predicate.
+ * @evidence contracts/performance.md#efficient-algorithms Each new context serializes cwd, options and aliases, then resolves and deduplicates E entries and reads their source bytes once. Capture starts without waiting for other entries; native capture and proof retain their own costs. Repeated requests serialize the context but do not reread the entries.
+ * @evidence contracts/performance.md#reuse-equivalent-work One latest context per cache and epoch starts each entry once; ordinary project keys deduplicate entries in the same project. Context equality controls scheduling only, and retained results still need normal admission.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources A WeakMap retains one context string per live cache. Startup rejection handlers consume each detached promise; running captures and native resources remain cache-owned and withdrawal disposes their fulfilled generations. No cancellation deadline or entry-count cap is added.
+ */
+exports.TtscPrecompilation = void 0;
+(function (TtscPrecompilation) {
+    const contexts = new WeakMap();
+    /**
+     * Start every eligible explicit entry without waiting for its siblings.
+     * Failed speculative preparation is reported when its module is requested, so
+     * an unrelated delivered project's load can proceed.
+     *
+     * @evidence contracts/common.md#principled-implementation The context is installed before captures start, so recursive and concurrent deliveries cannot restart the same batch; only supported source entries reach normal core capture.
+     * @evidence contracts/common.md#clear-and-simple-design One synchronous loop separates startup ownership from asynchronous capture settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed entry reads are not fabricated as empty source, and rejected captures do not become successful output. Actual delivery remains the error boundary.
+     * @evidence contracts/common.md#meaningful-documentation Prose states parallel startup and deferred error reporting; callback and context ownership remain explicit.
+     * @evidence contracts/portability.md#os-neutral-implementation Native absolute entry paths are passed as exact paths to capture and source reads use the same cache-owned filesystem as generation validation.
+     * @evidence contracts/performance.md#efficient-algorithms Context serialization precedes one E-entry deduplicating loop and actual source-byte reads; captures overlap their asynchronous work rather than being awaited sequentially.
+     * @evidence contracts/performance.md#reuse-equivalent-work Identical latest cwd, options, aliases and epoch skip scheduling; project Promise identity and normal input proof decide compile reuse, independently of this scheduling record.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Context state follows its weak cache key. Every started capture receives a rejection handler immediately; its own core/cache owners release native resources, including withdrawal during capture.
+     */
+    function start(cache, options, aliasPaths, capture) {
+        if (options.precompile?.length === 0 ||
+            options.precompile === undefined ||
+            pluginsAreDisabled.pluginsAreDisabled(options.plugins))
+            return;
+        // Entry, project and projectRoot paths all use cwd. The same relative
+        // options under another directory select different work, even if the
+        // host retains its cache; capture coordinates must belong to this call.
+        const cwd = process.cwd();
+        const context = JSON.stringify([
+            cwd,
+            options,
+            aliasPaths,
+            transformCacheEpoch.transformCacheEpoch(cache),
+        ]);
+        if (contexts.get(cache) === context)
+            return;
+        contexts.set(cache, context);
+        const entries = new Set();
+        const filesystem = transformFilesystem.transformFilesystem(cache);
+        for (const entry of options.precompile) {
+            if (!isTransformTarget.isTransformTarget(entry))
+                continue;
+            const file = path.resolve(cwd, entry);
+            if (entries.has(file))
+                continue;
+            entries.add(file);
+            try {
+                const source = filesystem.readFile(file).toString("utf8");
+                void capture(file, source).catch(() => undefined);
+            }
+            catch {
+                // A missing entry must not poison another project's load. Its actual
+                // host delivery still owns the native read error and recovery.
+            }
+        }
+    }
+    TtscPrecompilation.start = start;
+    /**
+     * End startup ownership when the cache withdraws its generations.
+     *
+     * @evidence contracts/common.md#principled-implementation Withdrawal removes scheduling state with generation ownership so a later lifecycle can prepare the same entries again.
+     * @evidence contracts/common.md#clear-and-simple-design One weak-key deletion shares the cache's existing reset boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Clearing scheduling permission does not admit or cancel any compiled result.
+     * @evidence contracts/common.md#meaningful-documentation The headline identifies the same generation withdrawal boundary used by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation WeakMap deletion performs no native operation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms One identity deletion chooses no traversal or processing strategy.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation withdraws the previous scheduling record rather than reusing work.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Deletion releases the single scheduling record; native resources remain owned by generation withdrawal.
+     */
+    function clear(cache) {
+        contexts.delete(cache);
+    }
+    TtscPrecompilation.clear = clear;
+})(exports.TtscPrecompilation || (exports.TtscPrecompilation = {}));
+//# sourceMappingURL=TtscPrecompilation.js.map

package/lib/core/transform/TtscPrecompilation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtscPrecompilation.js","sources":["../../../src/core/transform/TtscPrecompilation.ts"],"sourcesContent":[null],"names":["TtscPrecompilation","pluginsAreDisabled","transformCacheEpoch","transformFilesystem","isTransformTarget"],"mappings":";;;;;;;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACcA;AAAjB,CAAA,UAAiB,kBAAkB,EAAA;AACjC,IAAA,MAAM,QAAQ,GAAG,IAAI,OAAO,EAA8B;AAE1D;;;;;;;;;;;;;AAaG;IACH,SAAgB,KAAK,CACnB,KAAyB,EACzB,OAAoC,EACpC,UAAgD,EAChD,OAA2D,EAAA;AAE3D,QAAA,IACE,OAAO,CAAC,UAAU,EAAE,MAAM,KAAK,CAAC;YAChC,OAAO,CAAC,UAAU,KAAK,SAAS;AAChC,YAAAC,qCAAkB,CAAC,OAAO,CAAC,OAAO,CAAC;YAEnC;;;;AAIF,QAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;YAC7B,GAAG;YACH,OAAO;YACP,UAAU;YACVC,uCAAmB,CAAC,KAAK,CAAC;AAC3B,SAAA,CAAC;AACF,QAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,OAAO;YAAE;AACrC,QAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC;AAC5B,QAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU;AACjC,QAAA,MAAM,UAAU,GAAGC,uCAAmB,CAAC,KAAK,CAAC;AAC7C,QAAA,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,UAAU,EAAE;AACtC,YAAA,IAAI,CAACC,mCAAiB,CAAC,KAAK,CAAC;gBAAE;YAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;AACrC,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE;AACvB,YAAA,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;AACjB,YAAA,IAAI;AACF,gBAAA,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;AACzD,gBAAA,KAAK,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,SAAS,CAAC;YACnD;AAAE,YAAA,MAAM;;;YAGR;QACF;IACF;AAvCgB,IAAA,kBAAA,CAAA,KAAK,QAuCpB;AAED;;;;;;;;;;;AAWG;IACH,SAAgB,KAAK,CAAC,KAAyB,EAAA;AAC7C,QAAA,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;IACxB;AAFgB,IAAA,kBAAA,CAAA,KAAK,QAEpB;AACH,CAAC,EAzEgBJ,0BAAkB,KAAlBA,0BAAkB,GAAA,EAAA,CAAA,CAAA;;"}

package/lib/core/transform/TtscPrecompilation.mjs

@@ -0,0 +1,101 @@
+import path from 'node:path';
+import { isTransformTarget } from '../isTransformTarget.mjs';
+import { transformCacheEpoch } from './cache/transformCacheEpoch.mjs';
+import { transformFilesystem } from './cache/transformFilesystem.mjs';
+import { pluginsAreDisabled } from './utils/pluginsAreDisabled.mjs';
+
+/**
+ * Schedule explicitly selected source entries before the host reaches their
+ * imports. Compilation and proof stay with the ordinary transform core.
+ *
+ * A host often discovers its next workspace project only after the preceding
+ * project's transform finishes (#1764). Starting known entries together avoids
+ * that dependency on host traversal order. Walking unrelated projects would
+ * execute plugins the user never selected, so this owner uses only the supplied
+ * entries. Preparation leaves module delivery and host registration to the
+ * actual request.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit entries authorize scheduling; the supplied core capture retains project selection, configuration identity and all generation proofs. The context contains the current working directory, options, aliases and delivery epoch, not new cache authority.
+ * @evidence contracts/common.md#clear-and-simple-design One scheduler owns per-cache startup deduplication and reset; the transform core owns compiled generations and their disposal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No directory-wide discovery, plugin substitution or skipped proof is introduced; preparation never impersonates a host module delivery.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains host traversal order, explicit effectful selection and separation from delivery; members state context lifetime and failure ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries resolve through native path semantics from the current cwd and read through the cache's filesystem boundary; source eligibility uses the adapter's existing shared predicate.
+ * @evidence contracts/performance.md#efficient-algorithms Each new context serializes cwd, options and aliases, then resolves and deduplicates E entries and reads their source bytes once. Capture starts without waiting for other entries; native capture and proof retain their own costs. Repeated requests serialize the context but do not reread the entries.
+ * @evidence contracts/performance.md#reuse-equivalent-work One latest context per cache and epoch starts each entry once; ordinary project keys deduplicate entries in the same project. Context equality controls scheduling only, and retained results still need normal admission.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources A WeakMap retains one context string per live cache. Startup rejection handlers consume each detached promise; running captures and native resources remain cache-owned and withdrawal disposes their fulfilled generations. No cancellation deadline or entry-count cap is added.
+ */
+var TtscPrecompilation;
+(function (TtscPrecompilation) {
+    const contexts = new WeakMap();
+    /**
+     * Start every eligible explicit entry without waiting for its siblings.
+     * Failed speculative preparation is reported when its module is requested, so
+     * an unrelated delivered project's load can proceed.
+     *
+     * @evidence contracts/common.md#principled-implementation The context is installed before captures start, so recursive and concurrent deliveries cannot restart the same batch; only supported source entries reach normal core capture.
+     * @evidence contracts/common.md#clear-and-simple-design One synchronous loop separates startup ownership from asynchronous capture settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed entry reads are not fabricated as empty source, and rejected captures do not become successful output. Actual delivery remains the error boundary.
+     * @evidence contracts/common.md#meaningful-documentation Prose states parallel startup and deferred error reporting; callback and context ownership remain explicit.
+     * @evidence contracts/portability.md#os-neutral-implementation Native absolute entry paths are passed as exact paths to capture and source reads use the same cache-owned filesystem as generation validation.
+     * @evidence contracts/performance.md#efficient-algorithms Context serialization precedes one E-entry deduplicating loop and actual source-byte reads; captures overlap their asynchronous work rather than being awaited sequentially.
+     * @evidence contracts/performance.md#reuse-equivalent-work Identical latest cwd, options, aliases and epoch skip scheduling; project Promise identity and normal input proof decide compile reuse, independently of this scheduling record.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Context state follows its weak cache key. Every started capture receives a rejection handler immediately; its own core/cache owners release native resources, including withdrawal during capture.
+     */
+    function start(cache, options, aliasPaths, capture) {
+        if (options.precompile?.length === 0 ||
+            options.precompile === undefined ||
+            pluginsAreDisabled(options.plugins))
+            return;
+        // Entry, project and projectRoot paths all use cwd. The same relative
+        // options under another directory select different work, even if the
+        // host retains its cache; capture coordinates must belong to this call.
+        const cwd = process.cwd();
+        const context = JSON.stringify([
+            cwd,
+            options,
+            aliasPaths,
+            transformCacheEpoch(cache),
+        ]);
+        if (contexts.get(cache) === context)
+            return;
+        contexts.set(cache, context);
+        const entries = new Set();
+        const filesystem = transformFilesystem(cache);
+        for (const entry of options.precompile) {
+            if (!isTransformTarget(entry))
+                continue;
+            const file = path.resolve(cwd, entry);
+            if (entries.has(file))
+                continue;
+            entries.add(file);
+            try {
+                const source = filesystem.readFile(file).toString("utf8");
+                void capture(file, source).catch(() => undefined);
+            }
+            catch {
+                // A missing entry must not poison another project's load. Its actual
+                // host delivery still owns the native read error and recovery.
+            }
+        }
+    }
+    TtscPrecompilation.start = start;
+    /**
+     * End startup ownership when the cache withdraws its generations.
+     *
+     * @evidence contracts/common.md#principled-implementation Withdrawal removes scheduling state with generation ownership so a later lifecycle can prepare the same entries again.
+     * @evidence contracts/common.md#clear-and-simple-design One weak-key deletion shares the cache's existing reset boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Clearing scheduling permission does not admit or cancel any compiled result.
+     * @evidence contracts/common.md#meaningful-documentation The headline identifies the same generation withdrawal boundary used by callers.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation WeakMap deletion performs no native operation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms One identity deletion chooses no traversal or processing strategy.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation withdraws the previous scheduling record rather than reusing work.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Deletion releases the single scheduling record; native resources remain owned by generation withdrawal.
+     */
+    function clear(cache) {
+        contexts.delete(cache);
+    }
+    TtscPrecompilation.clear = clear;
+})(TtscPrecompilation || (TtscPrecompilation = {}));
+
+export { TtscPrecompilation };
+//# sourceMappingURL=TtscPrecompilation.mjs.map

package/lib/core/transform/TtscPrecompilation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtscPrecompilation.mjs","sources":["../../../src/core/transform/TtscPrecompilation.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACG,IAAW;AAAjB,CAAA,UAAiB,kBAAkB,EAAA;AACjC,IAAA,MAAM,QAAQ,GAAG,IAAI,OAAO,EAA8B;AAE1D;;;;;;;;;;;;;AAaG;IACH,SAAgB,KAAK,CACnB,KAAyB,EACzB,OAAoC,EACpC,UAAgD,EAChD,OAA2D,EAAA;AAE3D,QAAA,IACE,OAAO,CAAC,UAAU,EAAE,MAAM,KAAK,CAAC;YAChC,OAAO,CAAC,UAAU,KAAK,SAAS;AAChC,YAAA,kBAAkB,CAAC,OAAO,CAAC,OAAO,CAAC;YAEnC;;;;AAIF,QAAA,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;YAC7B,GAAG;YACH,OAAO;YACP,UAAU;YACV,mBAAmB,CAAC,KAAK,CAAC;AAC3B,SAAA,CAAC;AACF,QAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,OAAO;YAAE;AACrC,QAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC;AAC5B,QAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU;AACjC,QAAA,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,CAAC;AAC7C,QAAA,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,UAAU,EAAE;AACtC,YAAA,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;gBAAE;YAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;AACrC,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE;AACvB,YAAA,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;AACjB,YAAA,IAAI;AACF,gBAAA,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;AACzD,gBAAA,KAAK,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,SAAS,CAAC;YACnD;AAAE,YAAA,MAAM;;;YAGR;QACF;IACF;AAvCgB,IAAA,kBAAA,CAAA,KAAK,QAuCpB;AAED;;;;;;;;;;;AAWG;IACH,SAAgB,KAAK,CAAC,KAAyB,EAAA;AAC7C,QAAA,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;IACxB;AAFgB,IAAA,kBAAA,CAAA,KAAK,QAEpB;AACH,CAAC,EAzEgB,kBAAkB,KAAlB,kBAAkB,GAAA,EAAA,CAAA,CAAA;;;;"}

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

@@ -38,5 +38,7 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    /** False only for speculative source reads before an actual module delivery. */
+    reportDivergence?: boolean;
     proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

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

@@ -38,5 +38,7 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    /** False only for speculative source reads before an actual module delivery. */
+    reportDivergence?: boolean;
     proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

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

@@ -38,5 +38,7 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    /** False only for speculative source reads before an actual module delivery. */
+    reportDivergence?: boolean;
     proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

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

@@ -40,7 +40,7 @@ function selectCachedGenerationAction(props) {
         projectRoot: props.cached.projectRoot,
         result: props.cached.result,
     }) &&
-        matchesCachedSource.matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof)) {
+        matchesCachedSource.matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof, props.reportDivergence)) {
         return "serve";
     }
     evictGeneration.evictGeneration(props.cache, props.key, props.generation);

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

@@ -1 +1 @@
-{"version":3,"file":"selectCachedGenerationAction.js","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":["isVolatileFile","envelopeDerivation","matchesCachedSource","evictGeneration"],"mappings":";;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAS5C,EAAA;IACC,IACE,CAACA,6BAAc,CAACC,qCAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACFC,uCAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,CACZ,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAAC,+BAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}
+{"version":3,"file":"selectCachedGenerationAction.js","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":["isVolatileFile","envelopeDerivation","matchesCachedSource","evictGeneration"],"mappings":";;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAW5C,EAAA;IACC,IACE,CAACA,6BAAc,CAACC,qCAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACFC,uCAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,gBAAgB,CACvB,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAAC,+BAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}

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

@@ -38,7 +38,7 @@ function selectCachedGenerationAction(props) {
         projectRoot: props.cached.projectRoot,
         result: props.cached.result,
     }) &&
-        matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof)) {
+        matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof, props.reportDivergence)) {
         return "serve";
     }
     evictGeneration(props.cache, props.key, props.generation);

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

@@ -1 +1 @@
-{"version":3,"file":"selectCachedGenerationAction.mjs","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAS5C,EAAA;IACC,IACE,CAAC,cAAc,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACF,mBAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,CACZ,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}
+{"version":3,"file":"selectCachedGenerationAction.mjs","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAW5C,EAAA;IACC,IACE,CAAC,cAAc,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACF,mBAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,gBAAgB,CACvB,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}

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

@@ -1,5 +1,6 @@
 'use strict';
 
+var TtscPrecompilation = require('../TtscPrecompilation.js');
 var disposeCachedTransform = require('./disposeCachedTransform.js');
 
 /**
@@ -35,6 +36,7 @@ function withdrawTtscTransformGenerations(
 /** Cache whose generations are withdrawn while its delivery pass survives. */
 cache) {
     const generations = [...cache.values()];
+    TtscPrecompilation.TtscPrecompilation.clear(cache);
     cache.clear();
     for (const generation of generations) {
         void generation.then(disposeCachedTransform.disposeCachedTransform, () => undefined);

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

@@ -1 +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;;;;"}
+{"version":3,"file":"withdrawTtscTransformGenerations.js","sources":["../../../../src/core/transform/cache/withdrawTtscTransformGenerations.ts"],"sourcesContent":[null],"names":["TtscPrecompilation","disposeCachedTransform"],"mappings":";;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,gCAAgC;AAC9C;AACA,KAAyB,EAAA;IAEzB,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;AACvC,IAAAA,qCAAkB,CAAC,KAAK,CAAC,KAAK,CAAC;IAC/B,KAAK,CAAC,KAAK,EAAE;AACb,IAAA,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;QACpC,KAAK,UAAU,CAAC,IAAI,CAACC,6CAAsB,EAAE,MAAM,SAAS,CAAC;IAC/D;AACF;;;;"}

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

@@ -1,3 +1,4 @@
+import { TtscPrecompilation } from '../TtscPrecompilation.mjs';
 import { disposeCachedTransform } from './disposeCachedTransform.mjs';
 
 /**
@@ -33,6 +34,7 @@ function withdrawTtscTransformGenerations(
 /** Cache whose generations are withdrawn while its delivery pass survives. */
 cache) {
     const generations = [...cache.values()];
+    TtscPrecompilation.clear(cache);
     cache.clear();
     for (const generation of generations) {
         void generation.then(disposeCachedTransform, () => undefined);

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

@@ -1 +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;;;;"}
+{"version":3,"file":"withdrawTtscTransformGenerations.mjs","sources":["../../../../src/core/transform/cache/withdrawTtscTransformGenerations.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,gCAAgC;AAC9C;AACA,KAAyB,EAAA;IAEzB,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;AACvC,IAAA,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC;IAC/B,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/envelope/generationCaseSensitivity.d.cts

@@ -0,0 +1,32 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * The directory case answers of one generation's identity context
+ * (`envelopeDerivation`), for another identity context built while that
+ * generation is captured over the same filesystem view.
+ *
+ * Capturing a generation builds several identity contexts: the input selections
+ * and the trackers' baselines. Each asked every directory's case policy again,
+ * which on Windows costs an `fsutil` process for a directory whose names cannot
+ * settle it (samchon/ttsc#1742). They now ask the generation's own context,
+ * which memoizes each directory once for the generation. A view other than the
+ * one registered for the result observes for itself, and a tracker's re-check
+ * after an event still builds a context of its own.
+ *
+ * @evidence contracts/common.md#principled-implementation Sharing is admitted only for the filesystem view registered for the result, the view the generation context observes; any other view keeps its own observations.
+ * @evidence contracts/common.md#clear-and-simple-design One selector returns the generation's case operation, or the view's own for another view, and callers pass it to the existing context factory.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No answer is cached beyond the generation context that observed it, and a tracker's event re-check is not routed through it.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the repeated probes, the view condition and the re-check exception.
+ * @evidence contracts/portability.md#os-neutral-implementation The generation context observes case policy through the registered view's own probes; no platform assumption is introduced.
+ * @evidence contracts/performance.md#efficient-algorithms One registry lookup and one derivation lookup; the returned operation delegates to the generation context's memo.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every context capturing one generation shares the generation's answer for each directory.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The answers belong to the generation context, which the generation already owns; this selector retains nothing.
+ */
+export declare function generationCaseSensitivity(props: {
+    /** The view the caller's context observes through. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory of the generation. */
+    projectRoot: string;
+    /** The generation's compiler result. */
+    result: ITtscCompilerTransformation;
+}): TtscTransformFilesystemOperations["caseSensitive"];

package/lib/core/transform/envelope/generationCaseSensitivity.d.mts

@@ -0,0 +1,32 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * The directory case answers of one generation's identity context
+ * (`envelopeDerivation`), for another identity context built while that
+ * generation is captured over the same filesystem view.
+ *
+ * Capturing a generation builds several identity contexts: the input selections
+ * and the trackers' baselines. Each asked every directory's case policy again,
+ * which on Windows costs an `fsutil` process for a directory whose names cannot
+ * settle it (samchon/ttsc#1742). They now ask the generation's own context,
+ * which memoizes each directory once for the generation. A view other than the
+ * one registered for the result observes for itself, and a tracker's re-check
+ * after an event still builds a context of its own.
+ *
+ * @evidence contracts/common.md#principled-implementation Sharing is admitted only for the filesystem view registered for the result, the view the generation context observes; any other view keeps its own observations.
+ * @evidence contracts/common.md#clear-and-simple-design One selector returns the generation's case operation, or the view's own for another view, and callers pass it to the existing context factory.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No answer is cached beyond the generation context that observed it, and a tracker's event re-check is not routed through it.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the repeated probes, the view condition and the re-check exception.
+ * @evidence contracts/portability.md#os-neutral-implementation The generation context observes case policy through the registered view's own probes; no platform assumption is introduced.
+ * @evidence contracts/performance.md#efficient-algorithms One registry lookup and one derivation lookup; the returned operation delegates to the generation context's memo.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every context capturing one generation shares the generation's answer for each directory.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The answers belong to the generation context, which the generation already owns; this selector retains nothing.
+ */
+export declare function generationCaseSensitivity(props: {
+    /** The view the caller's context observes through. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory of the generation. */
+    projectRoot: string;
+    /** The generation's compiler result. */
+    result: ITtscCompilerTransformation;
+}): TtscTransformFilesystemOperations["caseSensitive"];

package/lib/core/transform/envelope/generationCaseSensitivity.d.ts

@@ -0,0 +1,32 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * The directory case answers of one generation's identity context
+ * (`envelopeDerivation`), for another identity context built while that
+ * generation is captured over the same filesystem view.
+ *
+ * Capturing a generation builds several identity contexts: the input selections
+ * and the trackers' baselines. Each asked every directory's case policy again,
+ * which on Windows costs an `fsutil` process for a directory whose names cannot
+ * settle it (samchon/ttsc#1742). They now ask the generation's own context,
+ * which memoizes each directory once for the generation. A view other than the
+ * one registered for the result observes for itself, and a tracker's re-check
+ * after an event still builds a context of its own.
+ *
+ * @evidence contracts/common.md#principled-implementation Sharing is admitted only for the filesystem view registered for the result, the view the generation context observes; any other view keeps its own observations.
+ * @evidence contracts/common.md#clear-and-simple-design One selector returns the generation's case operation, or the view's own for another view, and callers pass it to the existing context factory.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No answer is cached beyond the generation context that observed it, and a tracker's event re-check is not routed through it.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the repeated probes, the view condition and the re-check exception.
+ * @evidence contracts/portability.md#os-neutral-implementation The generation context observes case policy through the registered view's own probes; no platform assumption is introduced.
+ * @evidence contracts/performance.md#efficient-algorithms One registry lookup and one derivation lookup; the returned operation delegates to the generation context's memo.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every context capturing one generation shares the generation's answer for each directory.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The answers belong to the generation context, which the generation already owns; this selector retains nothing.
+ */
+export declare function generationCaseSensitivity(props: {
+    /** The view the caller's context observes through. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory of the generation. */
+    projectRoot: string;
+    /** The generation's compiler result. */
+    result: ITtscCompilerTransformation;
+}): TtscTransformFilesystemOperations["caseSensitive"];

package/lib/core/transform/envelope/generationCaseSensitivity.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var resultFilesystem = require('../cache/resultFilesystem.js');
+var envelopeDerivation = require('./envelopeDerivation.js');
+
+/**
+ * The directory case answers of one generation's identity context
+ * (`envelopeDerivation`), for another identity context built while that
+ * generation is captured over the same filesystem view.
+ *
+ * Capturing a generation builds several identity contexts: the input selections
+ * and the trackers' baselines. Each asked every directory's case policy again,
+ * which on Windows costs an `fsutil` process for a directory whose names cannot
+ * settle it (samchon/ttsc#1742). They now ask the generation's own context,
+ * which memoizes each directory once for the generation. A view other than the
+ * one registered for the result observes for itself, and a tracker's re-check
+ * after an event still builds a context of its own.
+ *
+ * @evidence contracts/common.md#principled-implementation Sharing is admitted only for the filesystem view registered for the result, the view the generation context observes; any other view keeps its own observations.
+ * @evidence contracts/common.md#clear-and-simple-design One selector returns the generation's case operation, or the view's own for another view, and callers pass it to the existing context factory.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No answer is cached beyond the generation context that observed it, and a tracker's event re-check is not routed through it.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the repeated probes, the view condition and the re-check exception.
+ * @evidence contracts/portability.md#os-neutral-implementation The generation context observes case policy through the registered view's own probes; no platform assumption is introduced.
+ * @evidence contracts/performance.md#efficient-algorithms One registry lookup and one derivation lookup; the returned operation delegates to the generation context's memo.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every context capturing one generation shares the generation's answer for each directory.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The answers belong to the generation context, which the generation already owns; this selector retains nothing.
+ */
+function generationCaseSensitivity(props) {
+    if (resultFilesystem.resultFilesystem(props.result) !== props.filesystem)
+        return props.filesystem.caseSensitive;
+    const context = envelopeDerivation.envelopeDerivation({
+        projectRoot: props.projectRoot,
+        result: props.result,
+    }).identityContext;
+    return (directory) => context.caseSensitive(directory);
+}
+
+exports.generationCaseSensitivity = generationCaseSensitivity;
+//# sourceMappingURL=generationCaseSensitivity.js.map

package/lib/core/transform/envelope/generationCaseSensitivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generationCaseSensitivity.js","sources":["../../../../src/core/transform/envelope/generationCaseSensitivity.ts"],"sourcesContent":[null],"names":["resultFilesystem","envelopeDerivation"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,yBAAyB,CAAC,KASzC,EAAA;IACC,IAAIA,iCAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,UAAU;AACrD,QAAA,OAAO,KAAK,CAAC,UAAU,CAAC,aAAa;IACvC,MAAM,OAAO,GAAGC,qCAAkB,CAAC;QACjC,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,MAAM,EAAE,KAAK,CAAC,MAAM;KACrB,CAAC,CAAC,eAAe;IAClB,OAAO,CAAC,SAAS,KAAK,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC;AACxD;;;;"}

package/lib/core/transform/envelope/generationCaseSensitivity.mjs

@@ -0,0 +1,37 @@
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { envelopeDerivation } from './envelopeDerivation.mjs';
+
+/**
+ * The directory case answers of one generation's identity context
+ * (`envelopeDerivation`), for another identity context built while that
+ * generation is captured over the same filesystem view.
+ *
+ * Capturing a generation builds several identity contexts: the input selections
+ * and the trackers' baselines. Each asked every directory's case policy again,
+ * which on Windows costs an `fsutil` process for a directory whose names cannot
+ * settle it (samchon/ttsc#1742). They now ask the generation's own context,
+ * which memoizes each directory once for the generation. A view other than the
+ * one registered for the result observes for itself, and a tracker's re-check
+ * after an event still builds a context of its own.
+ *
+ * @evidence contracts/common.md#principled-implementation Sharing is admitted only for the filesystem view registered for the result, the view the generation context observes; any other view keeps its own observations.
+ * @evidence contracts/common.md#clear-and-simple-design One selector returns the generation's case operation, or the view's own for another view, and callers pass it to the existing context factory.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No answer is cached beyond the generation context that observed it, and a tracker's event re-check is not routed through it.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the repeated probes, the view condition and the re-check exception.
+ * @evidence contracts/portability.md#os-neutral-implementation The generation context observes case policy through the registered view's own probes; no platform assumption is introduced.
+ * @evidence contracts/performance.md#efficient-algorithms One registry lookup and one derivation lookup; the returned operation delegates to the generation context's memo.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every context capturing one generation shares the generation's answer for each directory.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The answers belong to the generation context, which the generation already owns; this selector retains nothing.
+ */
+function generationCaseSensitivity(props) {
+    if (resultFilesystem(props.result) !== props.filesystem)
+        return props.filesystem.caseSensitive;
+    const context = envelopeDerivation({
+        projectRoot: props.projectRoot,
+        result: props.result,
+    }).identityContext;
+    return (directory) => context.caseSensitive(directory);
+}
+
+export { generationCaseSensitivity };
+//# sourceMappingURL=generationCaseSensitivity.mjs.map

package/lib/core/transform/envelope/generationCaseSensitivity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generationCaseSensitivity.mjs","sources":["../../../../src/core/transform/envelope/generationCaseSensitivity.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,yBAAyB,CAAC,KASzC,EAAA;IACC,IAAI,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,UAAU;AACrD,QAAA,OAAO,KAAK,CAAC,UAAU,CAAC,aAAa;IACvC,MAAM,OAAO,GAAG,kBAAkB,CAAC;QACjC,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,MAAM,EAAE,KAAK,CAAC,MAAM;KACrB,CAAC,CAAC,eAAe;IAClB,OAAO,CAAC,SAAS,KAAK,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC;AACxD;;;;"}

package/lib/core/transform/envelope/selectExternalInputPaths.js

@@ -8,6 +8,7 @@ var isProjectWalkPath = require('../project/isProjectWalkPath.js');
 var isTransformScratchInput = require('../tsconfig/isTransformScratchInput.js');
 var envelopeDerivation = require('./envelopeDerivation.js');
 var envelopeGraphIndexes = require('./envelopeGraphIndexes.js');
+var generationCaseSensitivity = require('./generationCaseSensitivity.js');
 
 /**
  * Derive the absolute out-of-walk input set of a whole project transform: the
@@ -54,7 +55,7 @@ function selectExternalInputPaths(props) {
     }
     const members = [];
     const filesystem = props.filesystem ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS;
-    const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem);
+    const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem, generationCaseSensitivity.generationCaseSensitivity({ ...props, filesystem }));
     const resolutionCandidates = new Set();
     const graph = props.result.graph;
     const graphState = envelopeDerivation.envelopeDerivation({