@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/generation/failedGenerationInputState.d.ts

@@ -0,0 +1,17 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Digest one exact out-of-walk path's metadata, content state, physical target
+ * and directory listing. Failed directory observation is distinct from a path
+ * that is not a directory; this is a retry-change fingerprint, not a success
+ * proof of an unreadable input.
+ *
+ * @evidence contracts/common.md#principled-implementation Metadata, host state, realpath and sorted entry-kind observations jointly represent exact-path changes; missing/unavailable states remain explicit in the serialized digest.
+ * @evidence contracts/common.md#clear-and-simple-design Existing input helpers own metadata/content/identity reads; this operation composes them with directory membership into one compact terminal comparison value.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures cannot equal an invented valid directory state, and a retained failure fingerprint does not certify unreadable compiler input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies fingerprint components, failed-directory distinctions and the difference between retry comparison and reusable-generation proof.
+ * @evidence contracts/portability.md#os-neutral-implementation All native observations use the injected filesystem boundary and host helpers; directory entry classifications come from actual Dirent capabilities rather than suffix or OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Following kind, metadata, content and realpath observations each retain native path/access costs; helpers can reread metadata and resolve ancestors rather than making a fixed observation count a time bound. A directory's N entries are materialized, their name/kind text sorted and joined before hashing, with comparison/encoding costs driven by text bytes and O(N) listing/frame storage. Content hashing additionally reads available bytes; sorting removes enumeration-order effects, not observation failures.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh observation fingerprint establishes a current comparison value; terminal environment validation owns metadata-first reuse and turn-shared verdicts.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a digest transfers to the caller; this operation owns no historical input-state cache, native handle or watcher lifecycle.
+ */
+export declare function failedGenerationInputState(input: string, filesystem: TtscTransformFilesystemOperations): string;

package/lib/core/transform/generation/failedGenerationInputState.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var hostInputRealpath = require('../inputs/hostInputRealpath.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var inputMetadataSignature = require('../inputs/inputMetadataSignature.js');
+var hashText = require('../utils/hashText.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+
+/**
+ * Digest one exact out-of-walk path's metadata, content state, physical target
+ * and directory listing. Failed directory observation is distinct from a path
+ * that is not a directory; this is a retry-change fingerprint, not a success
+ * proof of an unreadable input.
+ *
+ * @evidence contracts/common.md#principled-implementation Metadata, host state, realpath and sorted entry-kind observations jointly represent exact-path changes; missing/unavailable states remain explicit in the serialized digest.
+ * @evidence contracts/common.md#clear-and-simple-design Existing input helpers own metadata/content/identity reads; this operation composes them with directory membership into one compact terminal comparison value.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures cannot equal an invented valid directory state, and a retained failure fingerprint does not certify unreadable compiler input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies fingerprint components, failed-directory distinctions and the difference between retry comparison and reusable-generation proof.
+ * @evidence contracts/portability.md#os-neutral-implementation All native observations use the injected filesystem boundary and host helpers; directory entry classifications come from actual Dirent capabilities rather than suffix or OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Following kind, metadata, content and realpath observations each retain native path/access costs; helpers can reread metadata and resolve ancestors rather than making a fixed observation count a time bound. A directory's N entries are materialized, their name/kind text sorted and joined before hashing, with comparison/encoding costs driven by text bytes and O(N) listing/frame storage. Content hashing additionally reads available bytes; sorting removes enumeration-order effects, not observation failures.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh observation fingerprint establishes a current comparison value; terminal environment validation owns metadata-first reuse and turn-shared verdicts.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a digest transfers to the caller; this operation owns no historical input-state cache, native handle or watcher lifecycle.
+ */
+function failedGenerationInputState(input, filesystem) {
+    let directory = "not-directory";
+    try {
+        if (filesystem.stat(input).isDirectory()) {
+            directory = hashText.hashText(filesystem
+                .readdir(input)
+                .map((entry) => [
+                entry.name,
+                entry.isDirectory(),
+                entry.isFile(),
+                entry.isSymbolicLink(),
+            ].join(":"))
+                .sort()
+                .join("\0"));
+        }
+    }
+    catch {
+        directory = "unavailable";
+    }
+    return hashText.hashText(JSON.stringify([
+        inputMetadataSignature.inputMetadataSignature(input, filesystem) ?? "missing",
+        hostInputStateHash.hostInputStateHash(input, filesystem) ?? MISSING_INPUT_STATE.MISSING_INPUT_STATE,
+        hostInputRealpath.hostInputRealpath(input, filesystem),
+        directory,
+    ]));
+}
+
+exports.failedGenerationInputState = failedGenerationInputState;
+//# sourceMappingURL=failedGenerationInputState.js.map

package/lib/core/transform/generation/failedGenerationInputState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failedGenerationInputState.js","sources":["../../../../src/core/transform/generation/failedGenerationInputState.ts"],"sourcesContent":[null],"names":["hashText","inputMetadataSignature","hostInputStateHash","MISSING_INPUT_STATE","hostInputRealpath"],"mappings":";;;;;;;;AAOA;;;;;;;;;;;;;;AAcG;AACG,SAAU,0BAA0B,CACxC,KAAa,EACb,UAA6C,EAAA;IAE7C,IAAI,SAAS,GAAG,eAAe;AAC/B,IAAA,IAAI;QACF,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE;YACxC,SAAS,GAAGA,iBAAQ,CAClB;iBACG,OAAO,CAAC,KAAK;AACb,iBAAA,GAAG,CAAC,CAAC,KAAK,KACT;AACE,gBAAA,KAAK,CAAC,IAAI;gBACV,KAAK,CAAC,WAAW,EAAE;gBACnB,KAAK,CAAC,MAAM,EAAE;gBACd,KAAK,CAAC,cAAc,EAAE;AACvB,aAAA,CAAC,IAAI,CAAC,GAAG,CAAC;AAEZ,iBAAA,IAAI;AACJ,iBAAA,IAAI,CAAC,IAAI,CAAC,CACd;QACH;IACF;AAAE,IAAA,MAAM;QACN,SAAS,GAAG,aAAa;IAC3B;AACA,IAAA,OAAOA,iBAAQ,CACb,IAAI,CAAC,SAAS,CAAC;AACb,QAAAC,6CAAsB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,SAAS;AACtD,QAAAC,qCAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAIC,uCAAmB;AAC5D,QAAAC,mCAAiB,CAAC,KAAK,EAAE,UAAU,CAAC;QACpC,SAAS;AACV,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/transform/generation/failedGenerationInputState.mjs

@@ -0,0 +1,50 @@
+import { hostInputRealpath } from '../inputs/hostInputRealpath.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { inputMetadataSignature } from '../inputs/inputMetadataSignature.mjs';
+import { hashText } from '../utils/hashText.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+
+/**
+ * Digest one exact out-of-walk path's metadata, content state, physical target
+ * and directory listing. Failed directory observation is distinct from a path
+ * that is not a directory; this is a retry-change fingerprint, not a success
+ * proof of an unreadable input.
+ *
+ * @evidence contracts/common.md#principled-implementation Metadata, host state, realpath and sorted entry-kind observations jointly represent exact-path changes; missing/unavailable states remain explicit in the serialized digest.
+ * @evidence contracts/common.md#clear-and-simple-design Existing input helpers own metadata/content/identity reads; this operation composes them with directory membership into one compact terminal comparison value.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures cannot equal an invented valid directory state, and a retained failure fingerprint does not certify unreadable compiler input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies fingerprint components, failed-directory distinctions and the difference between retry comparison and reusable-generation proof.
+ * @evidence contracts/portability.md#os-neutral-implementation All native observations use the injected filesystem boundary and host helpers; directory entry classifications come from actual Dirent capabilities rather than suffix or OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Following kind, metadata, content and realpath observations each retain native path/access costs; helpers can reread metadata and resolve ancestors rather than making a fixed observation count a time bound. A directory's N entries are materialized, their name/kind text sorted and joined before hashing, with comparison/encoding costs driven by text bytes and O(N) listing/frame storage. Content hashing additionally reads available bytes; sorting removes enumeration-order effects, not observation failures.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh observation fingerprint establishes a current comparison value; terminal environment validation owns metadata-first reuse and turn-shared verdicts.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a digest transfers to the caller; this operation owns no historical input-state cache, native handle or watcher lifecycle.
+ */
+function failedGenerationInputState(input, filesystem) {
+    let directory = "not-directory";
+    try {
+        if (filesystem.stat(input).isDirectory()) {
+            directory = hashText(filesystem
+                .readdir(input)
+                .map((entry) => [
+                entry.name,
+                entry.isDirectory(),
+                entry.isFile(),
+                entry.isSymbolicLink(),
+            ].join(":"))
+                .sort()
+                .join("\0"));
+        }
+    }
+    catch {
+        directory = "unavailable";
+    }
+    return hashText(JSON.stringify([
+        inputMetadataSignature(input, filesystem) ?? "missing",
+        hostInputStateHash(input, filesystem) ?? MISSING_INPUT_STATE,
+        hostInputRealpath(input, filesystem),
+        directory,
+    ]));
+}
+
+export { failedGenerationInputState };
+//# sourceMappingURL=failedGenerationInputState.mjs.map

package/lib/core/transform/generation/failedGenerationInputState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"failedGenerationInputState.mjs","sources":["../../../../src/core/transform/generation/failedGenerationInputState.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;AAcG;AACG,SAAU,0BAA0B,CACxC,KAAa,EACb,UAA6C,EAAA;IAE7C,IAAI,SAAS,GAAG,eAAe;AAC/B,IAAA,IAAI;QACF,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE;YACxC,SAAS,GAAG,QAAQ,CAClB;iBACG,OAAO,CAAC,KAAK;AACb,iBAAA,GAAG,CAAC,CAAC,KAAK,KACT;AACE,gBAAA,KAAK,CAAC,IAAI;gBACV,KAAK,CAAC,WAAW,EAAE;gBACnB,KAAK,CAAC,MAAM,EAAE;gBACd,KAAK,CAAC,cAAc,EAAE;AACvB,aAAA,CAAC,IAAI,CAAC,GAAG,CAAC;AAEZ,iBAAA,IAAI;AACJ,iBAAA,IAAI,CAAC,IAAI,CAAC,CACd;QACH;IACF;AAAE,IAAA,MAAM;QACN,SAAS,GAAG,aAAa;IAC3B;AACA,IAAA,OAAO,QAAQ,CACb,IAAI,CAAC,SAAS,CAAC;AACb,QAAA,sBAAsB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,SAAS;AACtD,QAAA,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,mBAAmB;AAC5D,QAAA,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC;QACpC,SAAS;AACV,KAAA,CAAC,CACH;AACH;;;;"}

package/lib/core/transform/generation/mergeGenerationProofFailures.d.cts

@@ -0,0 +1,25 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/**
+ * Fold source witnesses into a target through the shared bounded recorder.
+ * Source omissions remain counted because their lost identities cannot be
+ * deduplicated against the target's retained evidence.
+ *
+ * Capture supplies distinct source and target collections, leaving the source
+ * unchanged. Retained witnesses are shared references, so producers must treat
+ * their classifications as fixed after recording.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Merge visits the source's recorder-bounded retained entries once. Each
+ *   delegated insertion encodes the complete witness tuple and queries its
+ *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   with at most eight entries. Omission addition is constant work; discarded
+ *   evidence is not reconstructed.
+ * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ */
+export declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

package/lib/core/transform/generation/mergeGenerationProofFailures.d.mts

@@ -0,0 +1,25 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.mjs";
+/**
+ * Fold source witnesses into a target through the shared bounded recorder.
+ * Source omissions remain counted because their lost identities cannot be
+ * deduplicated against the target's retained evidence.
+ *
+ * Capture supplies distinct source and target collections, leaving the source
+ * unchanged. Retained witnesses are shared references, so producers must treat
+ * their classifications as fixed after recording.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Merge visits the source's recorder-bounded retained entries once. Each
+ *   delegated insertion encodes the complete witness tuple and queries its
+ *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   with at most eight entries. Omission addition is constant work; discarded
+ *   evidence is not reconstructed.
+ * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ */
+export declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

package/lib/core/transform/generation/mergeGenerationProofFailures.d.ts

@@ -0,0 +1,25 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+/**
+ * Fold source witnesses into a target through the shared bounded recorder.
+ * Source omissions remain counted because their lost identities cannot be
+ * deduplicated against the target's retained evidence.
+ *
+ * Capture supplies distinct source and target collections, leaving the source
+ * unchanged. Retained witnesses are shared references, so producers must treat
+ * their classifications as fixed after recording.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Merge visits the source's recorder-bounded retained entries once. Each
+ *   delegated insertion encodes the complete witness tuple and queries its
+ *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   with at most eight entries. Omission addition is constant work; discarded
+ *   evidence is not reconstructed.
+ * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ */
+export declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

package/lib/core/transform/generation/mergeGenerationProofFailures.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var recordGenerationProofFailure = require('./recordGenerationProofFailure.js');
+
+/**
+ * Fold source witnesses into a target through the shared bounded recorder.
+ * Source omissions remain counted because their lost identities cannot be
+ * deduplicated against the target's retained evidence.
+ *
+ * Capture supplies distinct source and target collections, leaving the source
+ * unchanged. Retained witnesses are shared references, so producers must treat
+ * their classifications as fixed after recording.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Merge visits the source's recorder-bounded retained entries once. Each
+ *   delegated insertion encodes the complete witness tuple and queries its
+ *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   with at most eight entries. Omission addition is constant work; discarded
+ *   evidence is not reconstructed.
+ * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ */
+function mergeGenerationProofFailures(target, source) {
+    for (const failure of source.entries) {
+        recordGenerationProofFailure.recordGenerationProofFailure(target, failure);
+    }
+    target.omitted = Math.min(Number.MAX_SAFE_INTEGER, target.omitted + source.omitted);
+}
+
+exports.mergeGenerationProofFailures = mergeGenerationProofFailures;
+//# sourceMappingURL=mergeGenerationProofFailures.js.map

package/lib/core/transform/generation/mergeGenerationProofFailures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeGenerationProofFailures.js","sources":["../../../../src/core/transform/generation/mergeGenerationProofFailures.ts"],"sourcesContent":[null],"names":["recordGenerationProofFailure"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,4BAA4B,CAC1C,MAAmC,EACnC,MAAmC,EAAA;AAEnC,IAAA,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE;AACpC,QAAAA,yDAA4B,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/C;AACA,IAAA,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CACvB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAChC;AACH;;;;"}

package/lib/core/transform/generation/mergeGenerationProofFailures.mjs

@@ -0,0 +1,34 @@
+import { recordGenerationProofFailure } from './recordGenerationProofFailure.mjs';
+
+/**
+ * Fold source witnesses into a target through the shared bounded recorder.
+ * Source omissions remain counted because their lost identities cannot be
+ * deduplicated against the target's retained evidence.
+ *
+ * Capture supplies distinct source and target collections, leaving the source
+ * unchanged. Retained witnesses are shared references, so producers must treat
+ * their classifications as fixed after recording.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Merge visits the source's recorder-bounded retained entries once. Each
+ *   delegated insertion encodes the complete witness tuple and queries its
+ *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   with at most eight entries. Omission addition is constant work; discarded
+ *   evidence is not reconstructed.
+ * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ */
+function mergeGenerationProofFailures(target, source) {
+    for (const failure of source.entries) {
+        recordGenerationProofFailure(target, failure);
+    }
+    target.omitted = Math.min(Number.MAX_SAFE_INTEGER, target.omitted + source.omitted);
+}
+
+export { mergeGenerationProofFailures };
+//# sourceMappingURL=mergeGenerationProofFailures.mjs.map

package/lib/core/transform/generation/mergeGenerationProofFailures.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeGenerationProofFailures.mjs","sources":["../../../../src/core/transform/generation/mergeGenerationProofFailures.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,4BAA4B,CAC1C,MAAmC,EACnC,MAAmC,EAAA;AAEnC,IAAA,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE;AACpC,QAAA,4BAA4B,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/C;AACA,IAAA,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CACvB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAChC;AACH;;;;"}

package/lib/core/transform/generation/onlyLearnedCompileFacts.d.cts

@@ -0,0 +1,23 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/**
+ * Whether the retained, lossless failure aggregate names only facts learned
+ * after the attempt's pre-compile observation.
+ *
+ * The retry owner carries learned dependencies and compiler case policy into
+ * the next attempt, without spending its movement budget for this
+ * classification. This predicate classifies recorded failures, not independent
+ * disk stability; producers must record other failed proofs. An omitted witness
+ * could be anything, so it prevents that exemption. The retry owner separately
+ * enforces the absolute attempt cap and handles refuted adoptions.
+ *
+ * @param failures The attempt's recorded proof failures.
+ * @evidence contracts/common.md#principled-implementation A nonempty aggregate with omitted=0 and only dependency-unwitnessed or case-policy-learned qualifies for the retry owner's learned-fact exemption. This is classification of supplied witnesses, not a separate proof of project stability; omitted or other recorded failures prevent the exemption.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate centralizes which proof classes consume the retry movement budget, leaving actual attempts and the absolute cap to transformProject.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The recognized kinds express real compile facts learned after pre-witnessing, and no omitted or mixed failure is excused by a fixture-specific retry exception.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the missing-knowledge distinction, retry consequence and conservative dropped-witness rule, with params and acknowledgment separation.
+ * @evidence contracts/performance.md#efficient-algorithms Zero omissions and nonempty entries guard an every scan that stops at the first other kind. The recorder bounds normal retained count, while the supplied kind text still contributes to Set hashing/comparison. No per-call index or copied entry list is allocated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The fixed two-kind lookup table is algorithm data, not shared completed or in-flight computation. This predicate recomputes classification of the supplied aggregate; transformProject owns retries and learned observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the aggregate and reads a fixed private two-kind table. It acquires no retained per-attempt state, handle or running task and controls no aggregate lifecycle.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies failure kinds by a fixed set of strings; it reads no filesystem or path.
+ */
+export declare function onlyLearnedCompileFacts(failures: TtscGenerationProofFailures): boolean;

package/lib/core/transform/generation/onlyLearnedCompileFacts.d.mts

@@ -0,0 +1,23 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.mjs";
+/**
+ * Whether the retained, lossless failure aggregate names only facts learned
+ * after the attempt's pre-compile observation.
+ *
+ * The retry owner carries learned dependencies and compiler case policy into
+ * the next attempt, without spending its movement budget for this
+ * classification. This predicate classifies recorded failures, not independent
+ * disk stability; producers must record other failed proofs. An omitted witness
+ * could be anything, so it prevents that exemption. The retry owner separately
+ * enforces the absolute attempt cap and handles refuted adoptions.
+ *
+ * @param failures The attempt's recorded proof failures.
+ * @evidence contracts/common.md#principled-implementation A nonempty aggregate with omitted=0 and only dependency-unwitnessed or case-policy-learned qualifies for the retry owner's learned-fact exemption. This is classification of supplied witnesses, not a separate proof of project stability; omitted or other recorded failures prevent the exemption.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate centralizes which proof classes consume the retry movement budget, leaving actual attempts and the absolute cap to transformProject.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The recognized kinds express real compile facts learned after pre-witnessing, and no omitted or mixed failure is excused by a fixture-specific retry exception.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the missing-knowledge distinction, retry consequence and conservative dropped-witness rule, with params and acknowledgment separation.
+ * @evidence contracts/performance.md#efficient-algorithms Zero omissions and nonempty entries guard an every scan that stops at the first other kind. The recorder bounds normal retained count, while the supplied kind text still contributes to Set hashing/comparison. No per-call index or copied entry list is allocated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The fixed two-kind lookup table is algorithm data, not shared completed or in-flight computation. This predicate recomputes classification of the supplied aggregate; transformProject owns retries and learned observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the aggregate and reads a fixed private two-kind table. It acquires no retained per-attempt state, handle or running task and controls no aggregate lifecycle.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies failure kinds by a fixed set of strings; it reads no filesystem or path.
+ */
+export declare function onlyLearnedCompileFacts(failures: TtscGenerationProofFailures): boolean;

package/lib/core/transform/generation/onlyLearnedCompileFacts.d.ts

@@ -0,0 +1,23 @@
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+/**
+ * Whether the retained, lossless failure aggregate names only facts learned
+ * after the attempt's pre-compile observation.
+ *
+ * The retry owner carries learned dependencies and compiler case policy into
+ * the next attempt, without spending its movement budget for this
+ * classification. This predicate classifies recorded failures, not independent
+ * disk stability; producers must record other failed proofs. An omitted witness
+ * could be anything, so it prevents that exemption. The retry owner separately
+ * enforces the absolute attempt cap and handles refuted adoptions.
+ *
+ * @param failures The attempt's recorded proof failures.
+ * @evidence contracts/common.md#principled-implementation A nonempty aggregate with omitted=0 and only dependency-unwitnessed or case-policy-learned qualifies for the retry owner's learned-fact exemption. This is classification of supplied witnesses, not a separate proof of project stability; omitted or other recorded failures prevent the exemption.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate centralizes which proof classes consume the retry movement budget, leaving actual attempts and the absolute cap to transformProject.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The recognized kinds express real compile facts learned after pre-witnessing, and no omitted or mixed failure is excused by a fixture-specific retry exception.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the missing-knowledge distinction, retry consequence and conservative dropped-witness rule, with params and acknowledgment separation.
+ * @evidence contracts/performance.md#efficient-algorithms Zero omissions and nonempty entries guard an every scan that stops at the first other kind. The recorder bounds normal retained count, while the supplied kind text still contributes to Set hashing/comparison. No per-call index or copied entry list is allocated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The fixed two-kind lookup table is algorithm data, not shared completed or in-flight computation. This predicate recomputes classification of the supplied aggregate; transformProject owns retries and learned observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the aggregate and reads a fixed private two-kind table. It acquires no retained per-attempt state, handle or running task and controls no aggregate lifecycle.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies failure kinds by a fixed set of strings; it reads no filesystem or path.
+ */
+export declare function onlyLearnedCompileFacts(failures: TtscGenerationProofFailures): boolean;

package/lib/core/transform/generation/onlyLearnedCompileFacts.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/** Failures that say an attempt learned a fact of its compile too late to use. */
+const LEARNED_FACTS = new Set([
+    // A plugin-reported dependency path first named by this compile's envelope,
+    // which had no witness read before it (samchon/ttsc#1541).
+    "dependency-unwitnessed",
+    // The compiler's case policy, first reported by this compile's envelope,
+    // which the walk before it did not match under (samchon/ttsc#1545).
+    "case-policy-learned",
+]);
+/**
+ * Whether the retained, lossless failure aggregate names only facts learned
+ * after the attempt's pre-compile observation.
+ *
+ * The retry owner carries learned dependencies and compiler case policy into
+ * the next attempt, without spending its movement budget for this
+ * classification. This predicate classifies recorded failures, not independent
+ * disk stability; producers must record other failed proofs. An omitted witness
+ * could be anything, so it prevents that exemption. The retry owner separately
+ * enforces the absolute attempt cap and handles refuted adoptions.
+ *
+ * @param failures The attempt's recorded proof failures.
+ * @evidence contracts/common.md#principled-implementation A nonempty aggregate with omitted=0 and only dependency-unwitnessed or case-policy-learned qualifies for the retry owner's learned-fact exemption. This is classification of supplied witnesses, not a separate proof of project stability; omitted or other recorded failures prevent the exemption.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate centralizes which proof classes consume the retry movement budget, leaving actual attempts and the absolute cap to transformProject.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The recognized kinds express real compile facts learned after pre-witnessing, and no omitted or mixed failure is excused by a fixture-specific retry exception.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the missing-knowledge distinction, retry consequence and conservative dropped-witness rule, with params and acknowledgment separation.
+ * @evidence contracts/performance.md#efficient-algorithms Zero omissions and nonempty entries guard an every scan that stops at the first other kind. The recorder bounds normal retained count, while the supplied kind text still contributes to Set hashing/comparison. No per-call index or copied entry list is allocated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The fixed two-kind lookup table is algorithm data, not shared completed or in-flight computation. This predicate recomputes classification of the supplied aggregate; transformProject owns retries and learned observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the aggregate and reads a fixed private two-kind table. It acquires no retained per-attempt state, handle or running task and controls no aggregate lifecycle.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies failure kinds by a fixed set of strings; it reads no filesystem or path.
+ */
+function onlyLearnedCompileFacts(failures) {
+    return (failures.omitted === 0 &&
+        failures.entries.length !== 0 &&
+        failures.entries.every((failure) => LEARNED_FACTS.has(failure.kind)));
+}
+
+exports.onlyLearnedCompileFacts = onlyLearnedCompileFacts;
+//# sourceMappingURL=onlyLearnedCompileFacts.js.map

package/lib/core/transform/generation/onlyLearnedCompileFacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onlyLearnedCompileFacts.js","sources":["../../../../src/core/transform/generation/onlyLearnedCompileFacts.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;AACA,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC;;;IAG5B,wBAAwB;;;IAGxB,qBAAqB;AACtB,CAAA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,uBAAuB,CACrC,QAAqC,EAAA;AAErC,IAAA,QACE,QAAQ,CAAC,OAAO,KAAK,CAAC;AACtB,QAAA,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAC7B,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,KAAK,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAExE;;;;"}

package/lib/core/transform/generation/onlyLearnedCompileFacts.mjs

@@ -0,0 +1,38 @@
+/** Failures that say an attempt learned a fact of its compile too late to use. */
+const LEARNED_FACTS = new Set([
+    // A plugin-reported dependency path first named by this compile's envelope,
+    // which had no witness read before it (samchon/ttsc#1541).
+    "dependency-unwitnessed",
+    // The compiler's case policy, first reported by this compile's envelope,
+    // which the walk before it did not match under (samchon/ttsc#1545).
+    "case-policy-learned",
+]);
+/**
+ * Whether the retained, lossless failure aggregate names only facts learned
+ * after the attempt's pre-compile observation.
+ *
+ * The retry owner carries learned dependencies and compiler case policy into
+ * the next attempt, without spending its movement budget for this
+ * classification. This predicate classifies recorded failures, not independent
+ * disk stability; producers must record other failed proofs. An omitted witness
+ * could be anything, so it prevents that exemption. The retry owner separately
+ * enforces the absolute attempt cap and handles refuted adoptions.
+ *
+ * @param failures The attempt's recorded proof failures.
+ * @evidence contracts/common.md#principled-implementation A nonempty aggregate with omitted=0 and only dependency-unwitnessed or case-policy-learned qualifies for the retry owner's learned-fact exemption. This is classification of supplied witnesses, not a separate proof of project stability; omitted or other recorded failures prevent the exemption.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate centralizes which proof classes consume the retry movement budget, leaving actual attempts and the absolute cap to transformProject.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The recognized kinds express real compile facts learned after pre-witnessing, and no omitted or mixed failure is excused by a fixture-specific retry exception.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the missing-knowledge distinction, retry consequence and conservative dropped-witness rule, with params and acknowledgment separation.
+ * @evidence contracts/performance.md#efficient-algorithms Zero omissions and nonempty entries guard an every scan that stops at the first other kind. The recorder bounds normal retained count, while the supplied kind text still contributes to Set hashing/comparison. No per-call index or copied entry list is allocated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The fixed two-kind lookup table is algorithm data, not shared completed or in-flight computation. This predicate recomputes classification of the supplied aggregate; transformProject owns retries and learned observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the aggregate and reads a fixed private two-kind table. It acquires no retained per-attempt state, handle or running task and controls no aggregate lifecycle.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Classifies failure kinds by a fixed set of strings; it reads no filesystem or path.
+ */
+function onlyLearnedCompileFacts(failures) {
+    return (failures.omitted === 0 &&
+        failures.entries.length !== 0 &&
+        failures.entries.every((failure) => LEARNED_FACTS.has(failure.kind)));
+}
+
+export { onlyLearnedCompileFacts };
+//# sourceMappingURL=onlyLearnedCompileFacts.mjs.map

package/lib/core/transform/generation/onlyLearnedCompileFacts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"onlyLearnedCompileFacts.mjs","sources":["../../../../src/core/transform/generation/onlyLearnedCompileFacts.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;AACA,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC;;;IAG5B,wBAAwB;;;IAGxB,qBAAqB;AACtB,CAAA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,uBAAuB,CACrC,QAAqC,EAAA;AAErC,IAAA,QACE,QAAQ,CAAC,OAAO,KAAK,CAAC;AACtB,QAAA,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAC7B,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,KAAK,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAExE;;;;"}

package/lib/core/transform/generation/projectWalkFailureFingerprint.d.cts

@@ -0,0 +1,44 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscProjectWalkFailure } from "../project/TtscProjectWalkFailure.cjs";
+/**
+ * Hash the walk's declared-input-relevant failure shape for terminal retry
+ * comparison. File failures outside the declared keys are ignored; directory
+ * failures and unidentifiable paths remain relevant to walk completeness.
+ * Sorted failure/unstable lists make observation order irrelevant.
+ *
+ * This records producer classifications and resolved diagnostic spellings,
+ * rather than reopening paths to obtain error messages. Identity filtering
+ * shares the caller's observation transaction and may perform its native
+ * probes. A digest difference confirms a changed failure shape, not that a new
+ * generation can succeed.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys filter only file failures with resolvable identity; completeness, directory completeness and sorted kind/path observations preserve the failure shape under hashText's digest comparison premise.
+ * @evidence contracts/common.md#clear-and-simple-design This helper produces a compact comparison fingerprint while walkSnapshotComplete owns completeness semantics and toProjectKey owns filesystem identity mapping.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unidentifiable failed paths remain included rather than being dropped to manufacture a complete walk, and directory failures are not excused by declared-file selection.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared filtering, conservative identity failure, order-insensitive fingerprinting and its confirmation-only role before separated acknowledgments.
+ * @evidence contracts/portability.md#os-neutral-implementation Node resolves diagnostic native paths while toProjectKey uses the supplied filesystem identity context; no protocol slash or OS-name case assumption replaces path identity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Copies all unstable keys and scans all failures before sorting selected
+ *   collections, preserving the borrowed snapshot's order. Set lookups retain
+ *   key-text cost; declared file failures delegate native identity resolution
+ *   and containment to the supplied transaction. Completeness may scan unstable
+ *   keys again. Selected path resolution, string comparisons, JSON encoding
+ *   and UTF-8 hashing scale with diagnostic/key text; temporary arrays and
+ *   encoded text grow with the supplied and selected populations. Sorting is
+ *   needed because failure observation order is not retry identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   File filtering reuses path and directory-capability observations through
+ *   the caller's identity transaction. The completed fingerprint is not cached
+ *   here; terminal validation stores the baseline and compares a new snapshot.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary filtered/sorted arrays transfer only a digest string; no retained cache, handle or generation lifecycle is owned here.
+ */
+export declare function projectWalkFailureFingerprint(snapshot: {
+    /** Whether selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether relevant directory enumeration completed. */
+    directoryComplete: boolean;
+    /** Relative or full project identity keys with unstable observations. */
+    unstableFiles: ReadonlySet<string>;
+    /** Native failed-path observations and their producer classifications. */
+    walkFailures: readonly TtscProjectWalkFailure[];
+}, declared: ReadonlySet<string> | undefined, projectRoot: string, identities: FilesystemPathIdentityContext): string;

package/lib/core/transform/generation/projectWalkFailureFingerprint.d.mts

@@ -0,0 +1,44 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscProjectWalkFailure } from "../project/TtscProjectWalkFailure.mjs";
+/**
+ * Hash the walk's declared-input-relevant failure shape for terminal retry
+ * comparison. File failures outside the declared keys are ignored; directory
+ * failures and unidentifiable paths remain relevant to walk completeness.
+ * Sorted failure/unstable lists make observation order irrelevant.
+ *
+ * This records producer classifications and resolved diagnostic spellings,
+ * rather than reopening paths to obtain error messages. Identity filtering
+ * shares the caller's observation transaction and may perform its native
+ * probes. A digest difference confirms a changed failure shape, not that a new
+ * generation can succeed.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys filter only file failures with resolvable identity; completeness, directory completeness and sorted kind/path observations preserve the failure shape under hashText's digest comparison premise.
+ * @evidence contracts/common.md#clear-and-simple-design This helper produces a compact comparison fingerprint while walkSnapshotComplete owns completeness semantics and toProjectKey owns filesystem identity mapping.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unidentifiable failed paths remain included rather than being dropped to manufacture a complete walk, and directory failures are not excused by declared-file selection.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared filtering, conservative identity failure, order-insensitive fingerprinting and its confirmation-only role before separated acknowledgments.
+ * @evidence contracts/portability.md#os-neutral-implementation Node resolves diagnostic native paths while toProjectKey uses the supplied filesystem identity context; no protocol slash or OS-name case assumption replaces path identity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Copies all unstable keys and scans all failures before sorting selected
+ *   collections, preserving the borrowed snapshot's order. Set lookups retain
+ *   key-text cost; declared file failures delegate native identity resolution
+ *   and containment to the supplied transaction. Completeness may scan unstable
+ *   keys again. Selected path resolution, string comparisons, JSON encoding
+ *   and UTF-8 hashing scale with diagnostic/key text; temporary arrays and
+ *   encoded text grow with the supplied and selected populations. Sorting is
+ *   needed because failure observation order is not retry identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   File filtering reuses path and directory-capability observations through
+ *   the caller's identity transaction. The completed fingerprint is not cached
+ *   here; terminal validation stores the baseline and compares a new snapshot.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary filtered/sorted arrays transfer only a digest string; no retained cache, handle or generation lifecycle is owned here.
+ */
+export declare function projectWalkFailureFingerprint(snapshot: {
+    /** Whether selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether relevant directory enumeration completed. */
+    directoryComplete: boolean;
+    /** Relative or full project identity keys with unstable observations. */
+    unstableFiles: ReadonlySet<string>;
+    /** Native failed-path observations and their producer classifications. */
+    walkFailures: readonly TtscProjectWalkFailure[];
+}, declared: ReadonlySet<string> | undefined, projectRoot: string, identities: FilesystemPathIdentityContext): string;

package/lib/core/transform/generation/projectWalkFailureFingerprint.d.ts

@@ -0,0 +1,44 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscProjectWalkFailure } from "../project/TtscProjectWalkFailure";
+/**
+ * Hash the walk's declared-input-relevant failure shape for terminal retry
+ * comparison. File failures outside the declared keys are ignored; directory
+ * failures and unidentifiable paths remain relevant to walk completeness.
+ * Sorted failure/unstable lists make observation order irrelevant.
+ *
+ * This records producer classifications and resolved diagnostic spellings,
+ * rather than reopening paths to obtain error messages. Identity filtering
+ * shares the caller's observation transaction and may perform its native
+ * probes. A digest difference confirms a changed failure shape, not that a new
+ * generation can succeed.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys filter only file failures with resolvable identity; completeness, directory completeness and sorted kind/path observations preserve the failure shape under hashText's digest comparison premise.
+ * @evidence contracts/common.md#clear-and-simple-design This helper produces a compact comparison fingerprint while walkSnapshotComplete owns completeness semantics and toProjectKey owns filesystem identity mapping.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unidentifiable failed paths remain included rather than being dropped to manufacture a complete walk, and directory failures are not excused by declared-file selection.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared filtering, conservative identity failure, order-insensitive fingerprinting and its confirmation-only role before separated acknowledgments.
+ * @evidence contracts/portability.md#os-neutral-implementation Node resolves diagnostic native paths while toProjectKey uses the supplied filesystem identity context; no protocol slash or OS-name case assumption replaces path identity.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Copies all unstable keys and scans all failures before sorting selected
+ *   collections, preserving the borrowed snapshot's order. Set lookups retain
+ *   key-text cost; declared file failures delegate native identity resolution
+ *   and containment to the supplied transaction. Completeness may scan unstable
+ *   keys again. Selected path resolution, string comparisons, JSON encoding
+ *   and UTF-8 hashing scale with diagnostic/key text; temporary arrays and
+ *   encoded text grow with the supplied and selected populations. Sorting is
+ *   needed because failure observation order is not retry identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   File filtering reuses path and directory-capability observations through
+ *   the caller's identity transaction. The completed fingerprint is not cached
+ *   here; terminal validation stores the baseline and compares a new snapshot.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary filtered/sorted arrays transfer only a digest string; no retained cache, handle or generation lifecycle is owned here.
+ */
+export declare function projectWalkFailureFingerprint(snapshot: {
+    /** Whether selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether relevant directory enumeration completed. */
+    directoryComplete: boolean;
+    /** Relative or full project identity keys with unstable observations. */
+    unstableFiles: ReadonlySet<string>;
+    /** Native failed-path observations and their producer classifications. */
+    walkFailures: readonly TtscProjectWalkFailure[];
+}, declared: ReadonlySet<string> | undefined, projectRoot: string, identities: FilesystemPathIdentityContext): string;