@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/validation/sameProjectDirectories.d.ts

@@ -0,0 +1,17 @@
+import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot";
+/**
+ * Compare directory signatures relevant to either generation snapshot.
+ *
+ * Directories irrelevant on both sides cannot change program membership.
+ * Gaining or losing relevance remains visible from the side where it matters.
+ *
+ * @evidence contracts/common.md#principled-implementation The union of relevant directory paths compares membership signatures on both sides, preserving entry and exit from the program's relevant population.
+ * @evidence contracts/common.md#clear-and-simple-design One equality helper compares already deterministic snapshots without rediscovering compiler membership policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Relevance is supplied by the actual walk policy; unrelated output churn is not used to invalidate a generation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains both-sided relevance and why ignored-on-both directories cannot affect this proof.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares directory signatures by recorded path string; the strings were produced by the same walk, and no filesystem is read.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary maps and path sets are local and no history or native handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Both complete directory populations are scanned to select relevant entries. Two relevant maps and a union set give expected-constant entry lookup per relevant path; key hashing and signature equality retain their text costs. Temporary filtered arrays, map-entry pairs and union key collections grow with the selected relevant directories rather than retaining historical snapshots.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Snapshot admission owns sharing of the resulting proof; this helper computes one value comparison.
+ */
+export declare function sameProjectDirectories(left: readonly TtscProjectDirectorySnapshot[], right: readonly TtscProjectDirectorySnapshot[]): boolean;

package/lib/core/transform/validation/sameProjectDirectories.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Compare directory signatures relevant to either generation snapshot.
+ *
+ * Directories irrelevant on both sides cannot change program membership.
+ * Gaining or losing relevance remains visible from the side where it matters.
+ *
+ * @evidence contracts/common.md#principled-implementation The union of relevant directory paths compares membership signatures on both sides, preserving entry and exit from the program's relevant population.
+ * @evidence contracts/common.md#clear-and-simple-design One equality helper compares already deterministic snapshots without rediscovering compiler membership policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Relevance is supplied by the actual walk policy; unrelated output churn is not used to invalidate a generation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains both-sided relevance and why ignored-on-both directories cannot affect this proof.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares directory signatures by recorded path string; the strings were produced by the same walk, and no filesystem is read.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary maps and path sets are local and no history or native handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Both complete directory populations are scanned to select relevant entries. Two relevant maps and a union set give expected-constant entry lookup per relevant path; key hashing and signature equality retain their text costs. Temporary filtered arrays, map-entry pairs and union key collections grow with the selected relevant directories rather than retaining historical snapshots.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Snapshot admission owns sharing of the resulting proof; this helper computes one value comparison.
+ */
+function sameProjectDirectories(left, right) {
+    // Compare only the directories that can hold program inputs, on either side.
+    // A directory irrelevant on both is not part of the program's membership at
+    // all, so its appearance, disappearance or churn says nothing: that is a
+    // bundler's output tree. One that gained or lost relevance is present in the
+    // comparison from the side where it counts, and so is caught.
+    const select = (snapshots) => new Map(snapshots
+        .filter((directory) => directory.relevant)
+        .map((directory) => [directory.path, directory]));
+    const leftRelevant = select(left);
+    const rightRelevant = select(right);
+    const paths = new Set([...leftRelevant.keys(), ...rightRelevant.keys()]);
+    for (const location of paths) {
+        if (leftRelevant.get(location)?.signature !==
+            rightRelevant.get(location)?.signature) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.sameProjectDirectories = sameProjectDirectories;
+//# sourceMappingURL=sameProjectDirectories.js.map

package/lib/core/transform/validation/sameProjectDirectories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sameProjectDirectories.js","sources":["../../../../src/core/transform/validation/sameProjectDirectories.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;AAcG;AACG,SAAU,sBAAsB,CACpC,IAA6C,EAC7C,KAA8C,EAAA;;;;;;IAO9C,MAAM,MAAM,GAAG,CACb,SAAkD,KAElD,IAAI,GAAG,CACL;SACG,MAAM,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,QAAQ;AACxC,SAAA,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CACnD;AACH,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC;AACjC,IAAA,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC;AACnC,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,IAAI,EAAE,EAAE,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;AACxE,IAAA,KAAK,MAAM,QAAQ,IAAI,KAAK,EAAE;AAC5B,QAAA,IACE,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,SAAS;YACrC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,SAAS,EACtC;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/sameProjectDirectories.mjs

@@ -0,0 +1,38 @@
+/**
+ * Compare directory signatures relevant to either generation snapshot.
+ *
+ * Directories irrelevant on both sides cannot change program membership.
+ * Gaining or losing relevance remains visible from the side where it matters.
+ *
+ * @evidence contracts/common.md#principled-implementation The union of relevant directory paths compares membership signatures on both sides, preserving entry and exit from the program's relevant population.
+ * @evidence contracts/common.md#clear-and-simple-design One equality helper compares already deterministic snapshots without rediscovering compiler membership policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Relevance is supplied by the actual walk policy; unrelated output churn is not used to invalidate a generation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains both-sided relevance and why ignored-on-both directories cannot affect this proof.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares directory signatures by recorded path string; the strings were produced by the same walk, and no filesystem is read.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary maps and path sets are local and no history or native handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Both complete directory populations are scanned to select relevant entries. Two relevant maps and a union set give expected-constant entry lookup per relevant path; key hashing and signature equality retain their text costs. Temporary filtered arrays, map-entry pairs and union key collections grow with the selected relevant directories rather than retaining historical snapshots.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Snapshot admission owns sharing of the resulting proof; this helper computes one value comparison.
+ */
+function sameProjectDirectories(left, right) {
+    // Compare only the directories that can hold program inputs, on either side.
+    // A directory irrelevant on both is not part of the program's membership at
+    // all, so its appearance, disappearance or churn says nothing: that is a
+    // bundler's output tree. One that gained or lost relevance is present in the
+    // comparison from the side where it counts, and so is caught.
+    const select = (snapshots) => new Map(snapshots
+        .filter((directory) => directory.relevant)
+        .map((directory) => [directory.path, directory]));
+    const leftRelevant = select(left);
+    const rightRelevant = select(right);
+    const paths = new Set([...leftRelevant.keys(), ...rightRelevant.keys()]);
+    for (const location of paths) {
+        if (leftRelevant.get(location)?.signature !==
+            rightRelevant.get(location)?.signature) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { sameProjectDirectories };
+//# sourceMappingURL=sameProjectDirectories.mjs.map

package/lib/core/transform/validation/sameProjectDirectories.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sameProjectDirectories.mjs","sources":["../../../../src/core/transform/validation/sameProjectDirectories.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;AAcG;AACG,SAAU,sBAAsB,CACpC,IAA6C,EAC7C,KAA8C,EAAA;;;;;;IAO9C,MAAM,MAAM,GAAG,CACb,SAAkD,KAElD,IAAI,GAAG,CACL;SACG,MAAM,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,QAAQ;AACxC,SAAA,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CACnD;AACH,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC;AACjC,IAAA,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC;AACnC,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,IAAI,EAAE,EAAE,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;AACxE,IAAA,KAAK,MAAM,QAAQ,IAAI,KAAK,EAAE;AAC5B,QAAA,IACE,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,SAAS;YACrC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,SAAS,EACtC;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/trackerProvesInputUnchanged.d.cts

@@ -0,0 +1,18 @@
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.cjs";
+/**
+ * Whether a healthy notification scope proves one exact input unchanged: the
+ * tracker is live, its silence is proven, the input is one it watches by name,
+ * the watch below which the input lives was proven to deliver, and no event
+ * touched the input.
+ *
+ * @evidence contracts/common.md#principled-implementation Verified healthy content authority, exact covered spelling and no overlapping unproven scope or event establish this input's notification witness.
+ * @evidence contracts/common.md#clear-and-simple-design One shared predicate supplies universal and derived-input validators with the same notification authority rule.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quiet but failed, incomplete or undeliverable scopes are rejected rather than promoted to proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose enumerates health, coverage and overlap premises rather than treating silence as universal authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution and supplied overlap semantics qualify paths; fallback containment is component-aware rather than substring matching.
+ * @evidence contracts/performance.md#efficient-algorithms Health and exact covered-key checks precede sequential scans of unproven scopes and sampled changes, stopping at the first overlap. Cost follows those populations and each native identity or lexical path comparison; no project enumeration or source byte read occurs here.
+ * @evidence contracts/performance.md#reuse-equivalent-work This predicate qualifies reuse of a generation's recorded content from its current tracker witness. Exact coverage, verified delivery, complete healthy content authority and absence of overlapping uncertainty or events are all required; the boolean itself is recomputed rather than cached across tracker changes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function trackerProvesInputUnchanged(tracker: TtscProjectMutationTracker | undefined, input: string): boolean;

package/lib/core/transform/validation/trackerProvesInputUnchanged.d.mts

@@ -0,0 +1,18 @@
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.mjs";
+/**
+ * Whether a healthy notification scope proves one exact input unchanged: the
+ * tracker is live, its silence is proven, the input is one it watches by name,
+ * the watch below which the input lives was proven to deliver, and no event
+ * touched the input.
+ *
+ * @evidence contracts/common.md#principled-implementation Verified healthy content authority, exact covered spelling and no overlapping unproven scope or event establish this input's notification witness.
+ * @evidence contracts/common.md#clear-and-simple-design One shared predicate supplies universal and derived-input validators with the same notification authority rule.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quiet but failed, incomplete or undeliverable scopes are rejected rather than promoted to proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose enumerates health, coverage and overlap premises rather than treating silence as universal authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution and supplied overlap semantics qualify paths; fallback containment is component-aware rather than substring matching.
+ * @evidence contracts/performance.md#efficient-algorithms Health and exact covered-key checks precede sequential scans of unproven scopes and sampled changes, stopping at the first overlap. Cost follows those populations and each native identity or lexical path comparison; no project enumeration or source byte read occurs here.
+ * @evidence contracts/performance.md#reuse-equivalent-work This predicate qualifies reuse of a generation's recorded content from its current tracker witness. Exact coverage, verified delivery, complete healthy content authority and absence of overlapping uncertainty or events are all required; the boolean itself is recomputed rather than cached across tracker changes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function trackerProvesInputUnchanged(tracker: TtscProjectMutationTracker | undefined, input: string): boolean;

package/lib/core/transform/validation/trackerProvesInputUnchanged.d.ts

@@ -0,0 +1,18 @@
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker";
+/**
+ * Whether a healthy notification scope proves one exact input unchanged: the
+ * tracker is live, its silence is proven, the input is one it watches by name,
+ * the watch below which the input lives was proven to deliver, and no event
+ * touched the input.
+ *
+ * @evidence contracts/common.md#principled-implementation Verified healthy content authority, exact covered spelling and no overlapping unproven scope or event establish this input's notification witness.
+ * @evidence contracts/common.md#clear-and-simple-design One shared predicate supplies universal and derived-input validators with the same notification authority rule.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quiet but failed, incomplete or undeliverable scopes are rejected rather than promoted to proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose enumerates health, coverage and overlap premises rather than treating silence as universal authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution and supplied overlap semantics qualify paths; fallback containment is component-aware rather than substring matching.
+ * @evidence contracts/performance.md#efficient-algorithms Health and exact covered-key checks precede sequential scans of unproven scopes and sampled changes, stopping at the first overlap. Cost follows those populations and each native identity or lexical path comparison; no project enumeration or source byte read occurs here.
+ * @evidence contracts/performance.md#reuse-equivalent-work This predicate qualifies reuse of a generation's recorded content from its current tracker witness. Exact coverage, verified delivery, complete healthy content authority and absence of overlapping uncertainty or events are all required; the boolean itself is recomputed rather than cached across tracker changes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function trackerProvesInputUnchanged(tracker: TtscProjectMutationTracker | undefined, input: string): boolean;

package/lib/core/transform/validation/trackerProvesInputUnchanged.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var path = require('node:path');
+var pathIsWithin = require('../filesystem/pathIsWithin.js');
+
+/**
+ * Whether a healthy notification scope proves one exact input unchanged: the
+ * tracker is live, its silence is proven, the input is one it watches by name,
+ * the watch below which the input lives was proven to deliver, and no event
+ * touched the input.
+ *
+ * @evidence contracts/common.md#principled-implementation Verified healthy content authority, exact covered spelling and no overlapping unproven scope or event establish this input's notification witness.
+ * @evidence contracts/common.md#clear-and-simple-design One shared predicate supplies universal and derived-input validators with the same notification authority rule.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quiet but failed, incomplete or undeliverable scopes are rejected rather than promoted to proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose enumerates health, coverage and overlap premises rather than treating silence as universal authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution and supplied overlap semantics qualify paths; fallback containment is component-aware rather than substring matching.
+ * @evidence contracts/performance.md#efficient-algorithms Health and exact covered-key checks precede sequential scans of unproven scopes and sampled changes, stopping at the first overlap. Cost follows those populations and each native identity or lexical path comparison; no project enumeration or source byte read occurs here.
+ * @evidence contracts/performance.md#reuse-equivalent-work This predicate qualifies reuse of a generation's recorded content from its current tracker witness. Exact coverage, verified delivery, complete healthy content authority and absence of overlapping uncertainty or events are all required; the boolean itself is recomputed rather than cached across tracker changes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function trackerProvesInputUnchanged(tracker, input) {
+    if (tracker === undefined ||
+        tracker.failed ||
+        tracker.unverified === true ||
+        tracker.changesOmitted) {
+        return false;
+    }
+    if (tracker.contentAuthoritative !== true)
+        return false;
+    const absolute = path.resolve(input);
+    if (tracker.covered?.has(absolute) !== true)
+        return false;
+    // The watch below which the input lives could not prove it delivered, so
+    // its silence says nothing about this input (samchon/ttsc#1453).
+    for (const directory of tracker.unproven ?? []) {
+        if (tracker.overlaps?.(absolute, directory) ??
+            (pathIsWithin.pathIsWithin(absolute, directory) || pathIsWithin.pathIsWithin(directory, absolute))) {
+            return false;
+        }
+    }
+    for (const changed of tracker.changes) {
+        if (tracker.overlaps?.(absolute, changed) ??
+            (pathIsWithin.pathIsWithin(absolute, changed) || pathIsWithin.pathIsWithin(changed, absolute))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.trackerProvesInputUnchanged = trackerProvesInputUnchanged;
+//# sourceMappingURL=trackerProvesInputUnchanged.js.map

package/lib/core/transform/validation/trackerProvesInputUnchanged.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackerProvesInputUnchanged.js","sources":["../../../../src/core/transform/validation/trackerProvesInputUnchanged.ts"],"sourcesContent":[null],"names":["pathIsWithin"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;AAeG;AACG,SAAU,2BAA2B,CACzC,OAA+C,EAC/C,KAAa,EAAA;IAEb,IACE,OAAO,KAAK,SAAS;AACrB,QAAA,OAAO,CAAC,MAAM;QACd,OAAO,CAAC,UAAU,KAAK,IAAI;QAC3B,OAAO,CAAC,cAAc,EACtB;AACA,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IAAI,OAAO,CAAC,oBAAoB,KAAK,IAAI;AAAE,QAAA,OAAO,KAAK;IACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IACpC,IAAI,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;AAAE,QAAA,OAAO,KAAK;;;IAGzD,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,QAAQ,IAAI,EAAE,EAAE;QAC9C,IACE,OAAO,CAAC,QAAQ,GAAG,QAAQ,EAAE,SAAS,CAAC;AACvC,aAACA,yBAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,IAAIA,yBAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EACxE;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,OAAO,EAAE;QACrC,IACE,OAAO,CAAC,QAAQ,GAAG,QAAQ,EAAE,OAAO,CAAC;AACrC,aAACA,yBAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAIA,yBAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,EACpE;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/trackerProvesInputUnchanged.mjs

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import { pathIsWithin } from '../filesystem/pathIsWithin.mjs';
+
+/**
+ * Whether a healthy notification scope proves one exact input unchanged: the
+ * tracker is live, its silence is proven, the input is one it watches by name,
+ * the watch below which the input lives was proven to deliver, and no event
+ * touched the input.
+ *
+ * @evidence contracts/common.md#principled-implementation Verified healthy content authority, exact covered spelling and no overlapping unproven scope or event establish this input's notification witness.
+ * @evidence contracts/common.md#clear-and-simple-design One shared predicate supplies universal and derived-input validators with the same notification authority rule.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Quiet but failed, incomplete or undeliverable scopes are rejected rather than promoted to proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose enumerates health, coverage and overlap premises rather than treating silence as universal authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution and supplied overlap semantics qualify paths; fallback containment is component-aware rather than substring matching.
+ * @evidence contracts/performance.md#efficient-algorithms Health and exact covered-key checks precede sequential scans of unproven scopes and sampled changes, stopping at the first overlap. Cost follows those populations and each native identity or lexical path comparison; no project enumeration or source byte read occurs here.
+ * @evidence contracts/performance.md#reuse-equivalent-work This predicate qualifies reuse of a generation's recorded content from its current tracker witness. Exact coverage, verified delivery, complete healthy content authority and absence of overlapping uncertainty or events are all required; the boolean itself is recomputed rather than cached across tracker changes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function trackerProvesInputUnchanged(tracker, input) {
+    if (tracker === undefined ||
+        tracker.failed ||
+        tracker.unverified === true ||
+        tracker.changesOmitted) {
+        return false;
+    }
+    if (tracker.contentAuthoritative !== true)
+        return false;
+    const absolute = path.resolve(input);
+    if (tracker.covered?.has(absolute) !== true)
+        return false;
+    // The watch below which the input lives could not prove it delivered, so
+    // its silence says nothing about this input (samchon/ttsc#1453).
+    for (const directory of tracker.unproven ?? []) {
+        if (tracker.overlaps?.(absolute, directory) ??
+            (pathIsWithin(absolute, directory) || pathIsWithin(directory, absolute))) {
+            return false;
+        }
+    }
+    for (const changed of tracker.changes) {
+        if (tracker.overlaps?.(absolute, changed) ??
+            (pathIsWithin(absolute, changed) || pathIsWithin(changed, absolute))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { trackerProvesInputUnchanged };
+//# sourceMappingURL=trackerProvesInputUnchanged.mjs.map

package/lib/core/transform/validation/trackerProvesInputUnchanged.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackerProvesInputUnchanged.mjs","sources":["../../../../src/core/transform/validation/trackerProvesInputUnchanged.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;AAeG;AACG,SAAU,2BAA2B,CACzC,OAA+C,EAC/C,KAAa,EAAA;IAEb,IACE,OAAO,KAAK,SAAS;AACrB,QAAA,OAAO,CAAC,MAAM;QACd,OAAO,CAAC,UAAU,KAAK,IAAI;QAC3B,OAAO,CAAC,cAAc,EACtB;AACA,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IAAI,OAAO,CAAC,oBAAoB,KAAK,IAAI;AAAE,QAAA,OAAO,KAAK;IACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IACpC,IAAI,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;AAAE,QAAA,OAAO,KAAK;;;IAGzD,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,QAAQ,IAAI,EAAE,EAAE;QAC9C,IACE,OAAO,CAAC,QAAQ,GAAG,QAAQ,EAAE,SAAS,CAAC;AACvC,aAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,IAAI,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,EACxE;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,OAAO,EAAE;QACrC,IACE,OAAO,CAAC,QAAQ,GAAG,QAAQ,EAAE,OAAO,CAAC;AACrC,aAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,EACpE;AACA,YAAA,OAAO,KAAK;QACd;IACF;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/walkSnapshotComplete.d.cts

@@ -0,0 +1,29 @@
+/**
+ * Whether a project-walk snapshot is coherent for the inputs that matter.
+ *
+ * A capturing walk reads admitted regular files, including source artifacts
+ * that no compiled input consumed. Such a file can fail its own bracketed read
+ * while every declared input holds still. A validating walk may already limit
+ * those reads to declared keys. Attributable failure outside that population
+ * does not establish that the generation changed. A walk that could not
+ * enumerate a directory, or a file-level failure this snapshot could not
+ * attribute to a key, still taints everything: neither can be shown to leave
+ * the inputs alone.
+ *
+ * @evidence contracts/common.md#principled-implementation Global directory incompleteness taints all inputs, while attributable unstable files taint a declared generation only when their keys belong to its required population.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate separates enumeration coherence from file-level coherence without duplicating the filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown enumeration failures cannot be ignored as unrelated artifacts, and irrelevant file failures cannot invent a program inconsistency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain global enumeration failure and attributable non-input instability as distinct states.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Reads completeness flags and key sets of an already collected snapshot; it reads no filesystem.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the snapshot and retains no storage or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms Global flags precede one unstable-key scan with expected-constant Set entry lookup and early mismatch return; hashing or comparing a newly queried key retains its text cost. The predicate builds no secondary key collection.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning generation validator coordinates reused snapshots; this helper classifies one walk's authority.
+ */
+export declare function walkSnapshotComplete(snapshot: {
+    /** Whether all selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether enumeration and attribution establish every directory boundary. */
+    directoryComplete: boolean;
+    /** Project identity keys attributed to failed or unstable file observations. */
+    unstableFiles: ReadonlySet<string>;
+}, declared: ReadonlySet<string> | undefined): boolean;

package/lib/core/transform/validation/walkSnapshotComplete.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Whether a project-walk snapshot is coherent for the inputs that matter.
+ *
+ * A capturing walk reads admitted regular files, including source artifacts
+ * that no compiled input consumed. Such a file can fail its own bracketed read
+ * while every declared input holds still. A validating walk may already limit
+ * those reads to declared keys. Attributable failure outside that population
+ * does not establish that the generation changed. A walk that could not
+ * enumerate a directory, or a file-level failure this snapshot could not
+ * attribute to a key, still taints everything: neither can be shown to leave
+ * the inputs alone.
+ *
+ * @evidence contracts/common.md#principled-implementation Global directory incompleteness taints all inputs, while attributable unstable files taint a declared generation only when their keys belong to its required population.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate separates enumeration coherence from file-level coherence without duplicating the filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown enumeration failures cannot be ignored as unrelated artifacts, and irrelevant file failures cannot invent a program inconsistency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain global enumeration failure and attributable non-input instability as distinct states.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Reads completeness flags and key sets of an already collected snapshot; it reads no filesystem.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the snapshot and retains no storage or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms Global flags precede one unstable-key scan with expected-constant Set entry lookup and early mismatch return; hashing or comparing a newly queried key retains its text cost. The predicate builds no secondary key collection.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning generation validator coordinates reused snapshots; this helper classifies one walk's authority.
+ */
+export declare function walkSnapshotComplete(snapshot: {
+    /** Whether all selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether enumeration and attribution establish every directory boundary. */
+    directoryComplete: boolean;
+    /** Project identity keys attributed to failed or unstable file observations. */
+    unstableFiles: ReadonlySet<string>;
+}, declared: ReadonlySet<string> | undefined): boolean;

package/lib/core/transform/validation/walkSnapshotComplete.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Whether a project-walk snapshot is coherent for the inputs that matter.
+ *
+ * A capturing walk reads admitted regular files, including source artifacts
+ * that no compiled input consumed. Such a file can fail its own bracketed read
+ * while every declared input holds still. A validating walk may already limit
+ * those reads to declared keys. Attributable failure outside that population
+ * does not establish that the generation changed. A walk that could not
+ * enumerate a directory, or a file-level failure this snapshot could not
+ * attribute to a key, still taints everything: neither can be shown to leave
+ * the inputs alone.
+ *
+ * @evidence contracts/common.md#principled-implementation Global directory incompleteness taints all inputs, while attributable unstable files taint a declared generation only when their keys belong to its required population.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate separates enumeration coherence from file-level coherence without duplicating the filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown enumeration failures cannot be ignored as unrelated artifacts, and irrelevant file failures cannot invent a program inconsistency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain global enumeration failure and attributable non-input instability as distinct states.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Reads completeness flags and key sets of an already collected snapshot; it reads no filesystem.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the snapshot and retains no storage or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms Global flags precede one unstable-key scan with expected-constant Set entry lookup and early mismatch return; hashing or comparing a newly queried key retains its text cost. The predicate builds no secondary key collection.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning generation validator coordinates reused snapshots; this helper classifies one walk's authority.
+ */
+export declare function walkSnapshotComplete(snapshot: {
+    /** Whether all selected directory and file observations were coherent. */
+    complete: boolean;
+    /** Whether enumeration and attribution establish every directory boundary. */
+    directoryComplete: boolean;
+    /** Project identity keys attributed to failed or unstable file observations. */
+    unstableFiles: ReadonlySet<string>;
+}, declared: ReadonlySet<string> | undefined): boolean;

package/lib/core/transform/validation/walkSnapshotComplete.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Whether a project-walk snapshot is coherent for the inputs that matter.
+ *
+ * A capturing walk reads admitted regular files, including source artifacts
+ * that no compiled input consumed. Such a file can fail its own bracketed read
+ * while every declared input holds still. A validating walk may already limit
+ * those reads to declared keys. Attributable failure outside that population
+ * does not establish that the generation changed. A walk that could not
+ * enumerate a directory, or a file-level failure this snapshot could not
+ * attribute to a key, still taints everything: neither can be shown to leave
+ * the inputs alone.
+ *
+ * @evidence contracts/common.md#principled-implementation Global directory incompleteness taints all inputs, while attributable unstable files taint a declared generation only when their keys belong to its required population.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate separates enumeration coherence from file-level coherence without duplicating the filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown enumeration failures cannot be ignored as unrelated artifacts, and irrelevant file failures cannot invent a program inconsistency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain global enumeration failure and attributable non-input instability as distinct states.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Reads completeness flags and key sets of an already collected snapshot; it reads no filesystem.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the snapshot and retains no storage or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms Global flags precede one unstable-key scan with expected-constant Set entry lookup and early mismatch return; hashing or comparing a newly queried key retains its text cost. The predicate builds no secondary key collection.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning generation validator coordinates reused snapshots; this helper classifies one walk's authority.
+ */
+function walkSnapshotComplete(snapshot, declared) {
+    if (declared === undefined) {
+        return snapshot.complete;
+    }
+    if (!snapshot.directoryComplete) {
+        return false;
+    }
+    for (const key of snapshot.unstableFiles) {
+        if (declared.has(key))
+            return false;
+    }
+    return true;
+}
+
+exports.walkSnapshotComplete = walkSnapshotComplete;
+//# sourceMappingURL=walkSnapshotComplete.js.map

package/lib/core/transform/validation/walkSnapshotComplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walkSnapshotComplete.js","sources":["../../../../src/core/transform/validation/walkSnapshotComplete.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,oBAAoB,CAClC,QASC,EACD,QAAyC,EAAA;AAEzC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,OAAO,QAAQ,CAAC,QAAQ;IAC1B;AACA,IAAA,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE;AAC/B,QAAA,OAAO,KAAK;IACd;AACA,IAAA,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,aAAa,EAAE;AACxC,QAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AAAE,YAAA,OAAO,KAAK;IACrC;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/walkSnapshotComplete.mjs

@@ -0,0 +1,37 @@
+/**
+ * Whether a project-walk snapshot is coherent for the inputs that matter.
+ *
+ * A capturing walk reads admitted regular files, including source artifacts
+ * that no compiled input consumed. Such a file can fail its own bracketed read
+ * while every declared input holds still. A validating walk may already limit
+ * those reads to declared keys. Attributable failure outside that population
+ * does not establish that the generation changed. A walk that could not
+ * enumerate a directory, or a file-level failure this snapshot could not
+ * attribute to a key, still taints everything: neither can be shown to leave
+ * the inputs alone.
+ *
+ * @evidence contracts/common.md#principled-implementation Global directory incompleteness taints all inputs, while attributable unstable files taint a declared generation only when their keys belong to its required population.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate separates enumeration coherence from file-level coherence without duplicating the filesystem walk.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown enumeration failures cannot be ignored as unrelated artifacts, and irrelevant file failures cannot invent a program inconsistency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain global enumeration failure and attributable non-input instability as distinct states.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Reads completeness flags and key sets of an already collected snapshot; it reads no filesystem.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the snapshot and retains no storage or native resource.
+ * @evidence contracts/performance.md#efficient-algorithms Global flags precede one unstable-key scan with expected-constant Set entry lookup and early mismatch return; hashing or comparing a newly queried key retains its text cost. The predicate builds no secondary key collection.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning generation validator coordinates reused snapshots; this helper classifies one walk's authority.
+ */
+function walkSnapshotComplete(snapshot, declared) {
+    if (declared === undefined) {
+        return snapshot.complete;
+    }
+    if (!snapshot.directoryComplete) {
+        return false;
+    }
+    for (const key of snapshot.unstableFiles) {
+        if (declared.has(key))
+            return false;
+    }
+    return true;
+}
+
+export { walkSnapshotComplete };
+//# sourceMappingURL=walkSnapshotComplete.mjs.map

package/lib/core/transform/validation/walkSnapshotComplete.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"walkSnapshotComplete.mjs","sources":["../../../../src/core/transform/validation/walkSnapshotComplete.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,oBAAoB,CAClC,QASC,EACD,QAAyC,EAAA;AAEzC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,OAAO,QAAQ,CAAC,QAAQ;IAC1B;AACA,IAAA,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE;AAC/B,QAAA,OAAO,KAAK;IACd;AACA,IAAA,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,aAAa,EAAE;AACxC,QAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AAAE,YAAA,OAAO,KAAK;IACrC;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

package/lib/core/transform/validation/witnessExternalDependencies.d.cts

@@ -0,0 +1,32 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscExternalDependencyWitness } from "./TtscExternalDependencyWitness.cjs";
+/**
+ * Read the state of plugin-reported dependency paths before a compile, keyed by
+ * resolved spelling.
+ *
+ * A compile learns its dependency-only paths only from the envelope it returns,
+ * so the paths read here are the ones an earlier compile of the same project
+ * reported. A path the compile reports for the first time has no witness, and
+ * its generation is compiled again with one (samchon/ttsc#1541).
+ *
+ * @param paths Dependency-only paths an earlier compile reported.
+ * @param filesystem The filesystem the compile reads.
+ * @evidence contracts/common.md#principled-implementation Content, physical target and metadata boundaries are captured before compile; signature equality records one comparison rather than certifying an atomic read or usable metadata.
+ * @evidence contracts/common.md#clear-and-simple-design One witness constructor groups the dependency observations required by postcompile admission, leaving retry policy to generation ownership.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A newly reported path has no invented earlier witness; its owner must compile with a real pre-read observation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain earlier-report inputs and the first-discovery recompile premise before argument tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Injected native operations observe content, link targets and timestamps while lexical resolved spellings keep alias metadata witnesses distinct.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Witness ownership transfers to the compile attempt and temporary map size follows reported dependency paths; this helper acquires no persistent handle.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   N supplied occurrences each receive metadata/content/realpath/metadata
+ *   observations and native resolved-key construction. Bytes read/hash dominate
+ *   large files, while component/link resolution and metadata/bigint signature
+ *   text remain real costs. Duplicate resolved keys still reread and overwrite;
+ *   U final keys retain hashes/targets/signatures, not the read buffers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The attempt shares these precompile endpoints with postcompile admission,
+ *   which compares signatures, content and physical target and rejects absent
+ *   witnesses or changed comparisons. New paths need a later attempt with a
+ *   pre-read; matching endpoints are not a plugin-recorded read proof.
+ */
+export declare function witnessExternalDependencies(paths: readonly string[], filesystem: TtscTransformFilesystemOperations): Map<string, TtscExternalDependencyWitness>;

package/lib/core/transform/validation/witnessExternalDependencies.d.mts

@@ -0,0 +1,32 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscExternalDependencyWitness } from "./TtscExternalDependencyWitness.mjs";
+/**
+ * Read the state of plugin-reported dependency paths before a compile, keyed by
+ * resolved spelling.
+ *
+ * A compile learns its dependency-only paths only from the envelope it returns,
+ * so the paths read here are the ones an earlier compile of the same project
+ * reported. A path the compile reports for the first time has no witness, and
+ * its generation is compiled again with one (samchon/ttsc#1541).
+ *
+ * @param paths Dependency-only paths an earlier compile reported.
+ * @param filesystem The filesystem the compile reads.
+ * @evidence contracts/common.md#principled-implementation Content, physical target and metadata boundaries are captured before compile; signature equality records one comparison rather than certifying an atomic read or usable metadata.
+ * @evidence contracts/common.md#clear-and-simple-design One witness constructor groups the dependency observations required by postcompile admission, leaving retry policy to generation ownership.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A newly reported path has no invented earlier witness; its owner must compile with a real pre-read observation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain earlier-report inputs and the first-discovery recompile premise before argument tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Injected native operations observe content, link targets and timestamps while lexical resolved spellings keep alias metadata witnesses distinct.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Witness ownership transfers to the compile attempt and temporary map size follows reported dependency paths; this helper acquires no persistent handle.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   N supplied occurrences each receive metadata/content/realpath/metadata
+ *   observations and native resolved-key construction. Bytes read/hash dominate
+ *   large files, while component/link resolution and metadata/bigint signature
+ *   text remain real costs. Duplicate resolved keys still reread and overwrite;
+ *   U final keys retain hashes/targets/signatures, not the read buffers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The attempt shares these precompile endpoints with postcompile admission,
+ *   which compares signatures, content and physical target and rejects absent
+ *   witnesses or changed comparisons. New paths need a later attempt with a
+ *   pre-read; matching endpoints are not a plugin-recorded read proof.
+ */
+export declare function witnessExternalDependencies(paths: readonly string[], filesystem: TtscTransformFilesystemOperations): Map<string, TtscExternalDependencyWitness>;

package/lib/core/transform/validation/witnessExternalDependencies.d.ts

@@ -0,0 +1,32 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscExternalDependencyWitness } from "./TtscExternalDependencyWitness";
+/**
+ * Read the state of plugin-reported dependency paths before a compile, keyed by
+ * resolved spelling.
+ *
+ * A compile learns its dependency-only paths only from the envelope it returns,
+ * so the paths read here are the ones an earlier compile of the same project
+ * reported. A path the compile reports for the first time has no witness, and
+ * its generation is compiled again with one (samchon/ttsc#1541).
+ *
+ * @param paths Dependency-only paths an earlier compile reported.
+ * @param filesystem The filesystem the compile reads.
+ * @evidence contracts/common.md#principled-implementation Content, physical target and metadata boundaries are captured before compile; signature equality records one comparison rather than certifying an atomic read or usable metadata.
+ * @evidence contracts/common.md#clear-and-simple-design One witness constructor groups the dependency observations required by postcompile admission, leaving retry policy to generation ownership.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A newly reported path has no invented earlier witness; its owner must compile with a real pre-read observation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain earlier-report inputs and the first-discovery recompile premise before argument tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Injected native operations observe content, link targets and timestamps while lexical resolved spellings keep alias metadata witnesses distinct.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Witness ownership transfers to the compile attempt and temporary map size follows reported dependency paths; this helper acquires no persistent handle.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   N supplied occurrences each receive metadata/content/realpath/metadata
+ *   observations and native resolved-key construction. Bytes read/hash dominate
+ *   large files, while component/link resolution and metadata/bigint signature
+ *   text remain real costs. Duplicate resolved keys still reread and overwrite;
+ *   U final keys retain hashes/targets/signatures, not the read buffers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The attempt shares these precompile endpoints with postcompile admission,
+ *   which compares signatures, content and physical target and rejects absent
+ *   witnesses or changed comparisons. New paths need a later attempt with a
+ *   pre-read; matching endpoints are not a plugin-recorded read proof.
+ */
+export declare function witnessExternalDependencies(paths: readonly string[], filesystem: TtscTransformFilesystemOperations): Map<string, TtscExternalDependencyWitness>;