@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifiesAbsence.js","sources":["../../../../src/core/transform/validation/notifiesAbsence.ts"],"sourcesContent":[null],"names":["trackerProvesInputUnchanged"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;SACa,eAAe;AAC7B;AACA,MAAkC;AAClC;;;AAGG;AACH,KAAa,EAAA;IAEb,OAAOA,uDAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,KAAK,CAAC;AAC5E;;;;"}

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

@@ -0,0 +1,45 @@
+import { trackerProvesInputUnchanged } from './trackerProvesInputUnchanged.mjs';
+
+/**
+ * Report whether the generation's live candidate watcher still proves this
+ * exact spelling unchanged. Candidates include recorded fileExists:false
+ * predicates, which can describe directories as well as absent paths; the
+ * caller selects the recorded predicate or missing scalar it wants to reuse.
+ *
+ * Losing the watcher is not evidence of anything, so a failed tracker sends the
+ * input back to being probed by hand, exactly as a failed tracker already sends
+ * the whole generation back to complete-snapshot validation.
+ *
+ * @evidence contracts/common.md#principled-implementation The candidate tracker's exact coverage and healthy authoritative notification predicate qualify absence reuse.
+ * @evidence contracts/common.md#clear-and-simple-design One adapter selects the absence tracker without duplicating watcher-health policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A missing or failed candidate observer cannot prove continued absence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain exact spelling and why proof loss returns to direct probing.
+ * @evidence contracts/portability.md#os-neutral-implementation Authority comes from observed native delivery capability and the tracker's component-aware overlap semantics.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Candidate tracker selection is fixed work, but the proof checks exact
+ *   native coverage and scans unproven scopes/events until an overlap. Costs
+ *   follow their populations and delegated native identity/path comparisons;
+ *   it does not read candidate bytes or enumerate a project here.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Qualified current candidate notifications permit the caller's recorded
+ *   unavailable-file state to be reused without a direct probe. Missing
+ *   coverage, uncertainty or an
+ *   overlapping event withdraws that permission; the verdict is not cached
+ *   across tracker changes merely because the supplied path is unchanged.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Borrows the generation's candidate tracker and its identity/proof storage;
+ *   those owners control retained maps and handles, without new state here.
+ */
+function notifiesAbsence(
+/** Generation owning the separately scoped candidate observer. */
+cached, 
+/**
+ * Exact native candidate spelling; physical aliases alone do not grant
+ * coverage.
+ */
+input) {
+    return trackerProvesInputUnchanged(cached.candidateMutationTracker, input);
+}
+
+export { notifiesAbsence };
+//# sourceMappingURL=notifiesAbsence.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifiesAbsence.mjs","sources":["../../../../src/core/transform/validation/notifiesAbsence.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;SACa,eAAe;AAC7B;AACA,MAAkC;AAClC;;;AAGG;AACH,KAAa,EAAA;IAEb,OAAO,2BAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,KAAK,CAAC;AAC5E;;;;"}

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

@@ -0,0 +1,35 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.cjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.cjs";
+/**
+ * Remove missing or unreadable input claims from mutable tracker coverage. This
+ * is a postcapture filter, not independent admission of every remaining
+ * spelling; generation stability and tracker health must also hold.
+ *
+ * The observers must open before the post-compile snapshots so they can witness
+ * an A-B-A race. Their exact coverage can only be narrowed after those reads.
+ * Unreadable nondirectory and absent inputs can record the same `missing`
+ * state; neither may inherit a content shortcut because its metadata can stay
+ * fixed while bytes become readable. Missing resolver candidates inside the
+ * project retain their separate component-aware candidate tracker, while every
+ * other such input continues through the recorded predicate or directory-list
+ * proof.
+ *
+ * A plugin source directory has no entry, and is kept all the same: capture
+ * records it among the manifest's trees only once its state was proven
+ * (`pluginSourceHolds`, samchon/ttsc#1487), and the tracker watches it as a
+ * whole subtree. Qualified silence can serve its source files, but the build
+ * environment still needs separate proof. Dropping it left every delivery
+ * unable to take the manifest's notification shortcut, re-reading every
+ * universal input and proving every plugin source's state again.
+ *
+ * @evidence contracts/common.md#principled-implementation This filter removes explicit missing/unreadable host or external states, while admitted trees and kind/content-qualified entries keep their separate authority. Missing host validation alone does not clear the set or prove other spellings; full admission remains with capture and validators.
+ * @evidence contracts/common.md#clear-and-simple-design One postcapture operation reconciles watcher coverage with the admitted manifest rather than duplicating snapshot rules during observer acquisition.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Opening a watch cannot certify bytes capture could not read or invent content authority from metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain observer timing, unreadable states and the legitimate source-tree distinction.
+ * @evidence contracts/portability.md#os-neutral-implementation Lexical coverage and physical derivation identity remain separate so aliases and actual case policy cannot be conflated.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The existing coverage Set shrinks, without retaining old certification or acquiring watches; this does not itself release tracker registrations, generation identity memos or native resources owned elsewhere.
+ * @evidence contracts/performance.md#efficient-algorithms N covered spellings are copied before filtering, with O(N) temporary references plus path text and map/set lookup work. First derivation identities can perform native realpath/ancestor/case queries; generation memos share those observations. No content bytes or source tree are read here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Only capture-proven coverage remains eligible for shared notification validation; other spellings retain direct proof.
+ */
+export declare function restrictNotificationCoverageToProvenInputs(tracker: TtscProjectMutationTracker | undefined, cached: TtscCachedProjectTransform, hostValidation: TtscHostInputValidation | undefined): void;

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

@@ -0,0 +1,35 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.mjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.mjs";
+/**
+ * Remove missing or unreadable input claims from mutable tracker coverage. This
+ * is a postcapture filter, not independent admission of every remaining
+ * spelling; generation stability and tracker health must also hold.
+ *
+ * The observers must open before the post-compile snapshots so they can witness
+ * an A-B-A race. Their exact coverage can only be narrowed after those reads.
+ * Unreadable nondirectory and absent inputs can record the same `missing`
+ * state; neither may inherit a content shortcut because its metadata can stay
+ * fixed while bytes become readable. Missing resolver candidates inside the
+ * project retain their separate component-aware candidate tracker, while every
+ * other such input continues through the recorded predicate or directory-list
+ * proof.
+ *
+ * A plugin source directory has no entry, and is kept all the same: capture
+ * records it among the manifest's trees only once its state was proven
+ * (`pluginSourceHolds`, samchon/ttsc#1487), and the tracker watches it as a
+ * whole subtree. Qualified silence can serve its source files, but the build
+ * environment still needs separate proof. Dropping it left every delivery
+ * unable to take the manifest's notification shortcut, re-reading every
+ * universal input and proving every plugin source's state again.
+ *
+ * @evidence contracts/common.md#principled-implementation This filter removes explicit missing/unreadable host or external states, while admitted trees and kind/content-qualified entries keep their separate authority. Missing host validation alone does not clear the set or prove other spellings; full admission remains with capture and validators.
+ * @evidence contracts/common.md#clear-and-simple-design One postcapture operation reconciles watcher coverage with the admitted manifest rather than duplicating snapshot rules during observer acquisition.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Opening a watch cannot certify bytes capture could not read or invent content authority from metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain observer timing, unreadable states and the legitimate source-tree distinction.
+ * @evidence contracts/portability.md#os-neutral-implementation Lexical coverage and physical derivation identity remain separate so aliases and actual case policy cannot be conflated.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The existing coverage Set shrinks, without retaining old certification or acquiring watches; this does not itself release tracker registrations, generation identity memos or native resources owned elsewhere.
+ * @evidence contracts/performance.md#efficient-algorithms N covered spellings are copied before filtering, with O(N) temporary references plus path text and map/set lookup work. First derivation identities can perform native realpath/ancestor/case queries; generation memos share those observations. No content bytes or source tree are read here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Only capture-proven coverage remains eligible for shared notification validation; other spellings retain direct proof.
+ */
+export declare function restrictNotificationCoverageToProvenInputs(tracker: TtscProjectMutationTracker | undefined, cached: TtscCachedProjectTransform, hostValidation: TtscHostInputValidation | undefined): void;

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

@@ -0,0 +1,35 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation";
+/**
+ * Remove missing or unreadable input claims from mutable tracker coverage. This
+ * is a postcapture filter, not independent admission of every remaining
+ * spelling; generation stability and tracker health must also hold.
+ *
+ * The observers must open before the post-compile snapshots so they can witness
+ * an A-B-A race. Their exact coverage can only be narrowed after those reads.
+ * Unreadable nondirectory and absent inputs can record the same `missing`
+ * state; neither may inherit a content shortcut because its metadata can stay
+ * fixed while bytes become readable. Missing resolver candidates inside the
+ * project retain their separate component-aware candidate tracker, while every
+ * other such input continues through the recorded predicate or directory-list
+ * proof.
+ *
+ * A plugin source directory has no entry, and is kept all the same: capture
+ * records it among the manifest's trees only once its state was proven
+ * (`pluginSourceHolds`, samchon/ttsc#1487), and the tracker watches it as a
+ * whole subtree. Qualified silence can serve its source files, but the build
+ * environment still needs separate proof. Dropping it left every delivery
+ * unable to take the manifest's notification shortcut, re-reading every
+ * universal input and proving every plugin source's state again.
+ *
+ * @evidence contracts/common.md#principled-implementation This filter removes explicit missing/unreadable host or external states, while admitted trees and kind/content-qualified entries keep their separate authority. Missing host validation alone does not clear the set or prove other spellings; full admission remains with capture and validators.
+ * @evidence contracts/common.md#clear-and-simple-design One postcapture operation reconciles watcher coverage with the admitted manifest rather than duplicating snapshot rules during observer acquisition.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Opening a watch cannot certify bytes capture could not read or invent content authority from metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain observer timing, unreadable states and the legitimate source-tree distinction.
+ * @evidence contracts/portability.md#os-neutral-implementation Lexical coverage and physical derivation identity remain separate so aliases and actual case policy cannot be conflated.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The existing coverage Set shrinks, without retaining old certification or acquiring watches; this does not itself release tracker registrations, generation identity memos or native resources owned elsewhere.
+ * @evidence contracts/performance.md#efficient-algorithms N covered spellings are copied before filtering, with O(N) temporary references plus path text and map/set lookup work. First derivation identities can perform native realpath/ancestor/case queries; generation memos share those observations. No content bytes or source tree are read here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Only capture-proven coverage remains eligible for shared notification validation; other spellings retain direct proof.
+ */
+export declare function restrictNotificationCoverageToProvenInputs(tracker: TtscProjectMutationTracker | undefined, cached: TtscCachedProjectTransform, hostValidation: TtscHostInputValidation | undefined): void;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+var path = require('node:path');
+var derivationIdentity = require('../envelope/derivationIdentity.js');
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var MISSING_INPUT_STATE = require('./MISSING_INPUT_STATE.js');
+
+/**
+ * Remove missing or unreadable input claims from mutable tracker coverage. This
+ * is a postcapture filter, not independent admission of every remaining
+ * spelling; generation stability and tracker health must also hold.
+ *
+ * The observers must open before the post-compile snapshots so they can witness
+ * an A-B-A race. Their exact coverage can only be narrowed after those reads.
+ * Unreadable nondirectory and absent inputs can record the same `missing`
+ * state; neither may inherit a content shortcut because its metadata can stay
+ * fixed while bytes become readable. Missing resolver candidates inside the
+ * project retain their separate component-aware candidate tracker, while every
+ * other such input continues through the recorded predicate or directory-list
+ * proof.
+ *
+ * A plugin source directory has no entry, and is kept all the same: capture
+ * records it among the manifest's trees only once its state was proven
+ * (`pluginSourceHolds`, samchon/ttsc#1487), and the tracker watches it as a
+ * whole subtree. Qualified silence can serve its source files, but the build
+ * environment still needs separate proof. Dropping it left every delivery
+ * unable to take the manifest's notification shortcut, re-reading every
+ * universal input and proving every plugin source's state again.
+ *
+ * @evidence contracts/common.md#principled-implementation This filter removes explicit missing/unreadable host or external states, while admitted trees and kind/content-qualified entries keep their separate authority. Missing host validation alone does not clear the set or prove other spellings; full admission remains with capture and validators.
+ * @evidence contracts/common.md#clear-and-simple-design One postcapture operation reconciles watcher coverage with the admitted manifest rather than duplicating snapshot rules during observer acquisition.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Opening a watch cannot certify bytes capture could not read or invent content authority from metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain observer timing, unreadable states and the legitimate source-tree distinction.
+ * @evidence contracts/portability.md#os-neutral-implementation Lexical coverage and physical derivation identity remain separate so aliases and actual case policy cannot be conflated.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The existing coverage Set shrinks, without retaining old certification or acquiring watches; this does not itself release tracker registrations, generation identity memos or native resources owned elsewhere.
+ * @evidence contracts/performance.md#efficient-algorithms N covered spellings are copied before filtering, with O(N) temporary references plus path text and map/set lookup work. First derivation identities can perform native realpath/ancestor/case queries; generation memos share those observations. No content bytes or source tree are read here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Only capture-proven coverage remains eligible for shared notification validation; other spellings retain direct proof.
+ */
+function restrictNotificationCoverageToProvenInputs(tracker, cached, hostValidation) {
+    if (!(tracker?.covered instanceof Set))
+        return;
+    const covered = tracker.covered;
+    const state = envelopeDerivation.envelopeDerivation(cached);
+    for (const input of [...covered]) {
+        const absolute = path.resolve(input);
+        if (hostValidation?.trees.has(absolute) === true)
+            continue;
+        const hostEntry = hostValidation?.entries.get(absolute);
+        if ((hostValidation?.covered.has(absolute) === true &&
+            (hostEntry === undefined ||
+                (hostEntry.readable === false && hostEntry.strict !== true))) ||
+            cached.externalInputHashes?.[derivationIdentity.derivationIdentity(state, absolute)] ===
+                MISSING_INPUT_STATE.MISSING_INPUT_STATE ||
+            cached.externalInputObservations?.[absolute]?.readFile?.ok === false ||
+            cached.externalInputObservations?.[absolute]?.fileExists === false) {
+            covered.delete(input);
+        }
+    }
+}
+
+exports.restrictNotificationCoverageToProvenInputs = restrictNotificationCoverageToProvenInputs;
+//# sourceMappingURL=restrictNotificationCoverageToProvenInputs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"restrictNotificationCoverageToProvenInputs.js","sources":["../../../../src/core/transform/validation/restrictNotificationCoverageToProvenInputs.ts"],"sourcesContent":[null],"names":["envelopeDerivation","derivationIdentity","MISSING_INPUT_STATE"],"mappings":";;;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;SACa,0CAA0C,CACxD,OAA+C,EAC/C,MAAkC,EAClC,cAAmD,EAAA;AAEnD,IAAA,IAAI,EAAE,OAAO,EAAE,OAAO,YAAY,GAAG,CAAC;QAAE;AACxC,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,OAAsB;AAC9C,IAAA,MAAM,KAAK,GAAGA,qCAAkB,CAAC,MAAM,CAAC;IACxC,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,EAAE;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACpC,IAAI,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;YAAE;QAClD,MAAM,SAAS,GAAG,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;QACvD,IACE,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;aAC5C,SAAS,KAAK,SAAS;AACtB,iBAAC,SAAS,CAAC,QAAQ,KAAK,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;YAChE,MAAM,CAAC,mBAAmB,GAAGC,qCAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBAC/DC,uCAAmB;YACrB,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,KAAK;YACpE,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC,EAAE,UAAU,KAAK,KAAK,EAClE;AACA,YAAA,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;QACvB;IACF;AACF;;;;"}

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

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { derivationIdentity } from '../envelope/derivationIdentity.mjs';
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { MISSING_INPUT_STATE } from './MISSING_INPUT_STATE.mjs';
+
+/**
+ * Remove missing or unreadable input claims from mutable tracker coverage. This
+ * is a postcapture filter, not independent admission of every remaining
+ * spelling; generation stability and tracker health must also hold.
+ *
+ * The observers must open before the post-compile snapshots so they can witness
+ * an A-B-A race. Their exact coverage can only be narrowed after those reads.
+ * Unreadable nondirectory and absent inputs can record the same `missing`
+ * state; neither may inherit a content shortcut because its metadata can stay
+ * fixed while bytes become readable. Missing resolver candidates inside the
+ * project retain their separate component-aware candidate tracker, while every
+ * other such input continues through the recorded predicate or directory-list
+ * proof.
+ *
+ * A plugin source directory has no entry, and is kept all the same: capture
+ * records it among the manifest's trees only once its state was proven
+ * (`pluginSourceHolds`, samchon/ttsc#1487), and the tracker watches it as a
+ * whole subtree. Qualified silence can serve its source files, but the build
+ * environment still needs separate proof. Dropping it left every delivery
+ * unable to take the manifest's notification shortcut, re-reading every
+ * universal input and proving every plugin source's state again.
+ *
+ * @evidence contracts/common.md#principled-implementation This filter removes explicit missing/unreadable host or external states, while admitted trees and kind/content-qualified entries keep their separate authority. Missing host validation alone does not clear the set or prove other spellings; full admission remains with capture and validators.
+ * @evidence contracts/common.md#clear-and-simple-design One postcapture operation reconciles watcher coverage with the admitted manifest rather than duplicating snapshot rules during observer acquisition.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Opening a watch cannot certify bytes capture could not read or invent content authority from metadata.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain observer timing, unreadable states and the legitimate source-tree distinction.
+ * @evidence contracts/portability.md#os-neutral-implementation Lexical coverage and physical derivation identity remain separate so aliases and actual case policy cannot be conflated.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The existing coverage Set shrinks, without retaining old certification or acquiring watches; this does not itself release tracker registrations, generation identity memos or native resources owned elsewhere.
+ * @evidence contracts/performance.md#efficient-algorithms N covered spellings are copied before filtering, with O(N) temporary references plus path text and map/set lookup work. First derivation identities can perform native realpath/ancestor/case queries; generation memos share those observations. No content bytes or source tree are read here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Only capture-proven coverage remains eligible for shared notification validation; other spellings retain direct proof.
+ */
+function restrictNotificationCoverageToProvenInputs(tracker, cached, hostValidation) {
+    if (!(tracker?.covered instanceof Set))
+        return;
+    const covered = tracker.covered;
+    const state = envelopeDerivation(cached);
+    for (const input of [...covered]) {
+        const absolute = path.resolve(input);
+        if (hostValidation?.trees.has(absolute) === true)
+            continue;
+        const hostEntry = hostValidation?.entries.get(absolute);
+        if ((hostValidation?.covered.has(absolute) === true &&
+            (hostEntry === undefined ||
+                (hostEntry.readable === false && hostEntry.strict !== true))) ||
+            cached.externalInputHashes?.[derivationIdentity(state, absolute)] ===
+                MISSING_INPUT_STATE ||
+            cached.externalInputObservations?.[absolute]?.readFile?.ok === false ||
+            cached.externalInputObservations?.[absolute]?.fileExists === false) {
+            covered.delete(input);
+        }
+    }
+}
+
+export { restrictNotificationCoverageToProvenInputs };
+//# sourceMappingURL=restrictNotificationCoverageToProvenInputs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"restrictNotificationCoverageToProvenInputs.mjs","sources":["../../../../src/core/transform/validation/restrictNotificationCoverageToProvenInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;SACa,0CAA0C,CACxD,OAA+C,EAC/C,MAAkC,EAClC,cAAmD,EAAA;AAEnD,IAAA,IAAI,EAAE,OAAO,EAAE,OAAO,YAAY,GAAG,CAAC;QAAE;AACxC,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,OAAsB;AAC9C,IAAA,MAAM,KAAK,GAAG,kBAAkB,CAAC,MAAM,CAAC;IACxC,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,EAAE;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACpC,IAAI,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;YAAE;QAClD,MAAM,SAAS,GAAG,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;QACvD,IACE,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI;aAC5C,SAAS,KAAK,SAAS;AACtB,iBAAC,SAAS,CAAC,QAAQ,KAAK,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;YAChE,MAAM,CAAC,mBAAmB,GAAG,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBAC/D,mBAAmB;YACrB,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,KAAK;YACpE,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC,EAAE,UAAU,KAAK,KAAK,EAClE;AACA,YAAA,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;QACvB;IACF;AACF;;;;"}

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

@@ -0,0 +1,25 @@
+/**
+ * Compare two project-walk snapshots.
+ *
+ * `keys` narrows the comparison to the generation's declared inputs. The walk
+ * hashes admitted regular files under the project root, but only a file the
+ * compile actually consumed can change an output, and a project root is a
+ * working directory: a framework's generated types, a log, a coverage report,
+ * or a test artifact appears and changes there while a compile runs. Comparing
+ * those would declare the generation incoherent and cost a whole-project
+ * recompile for every remaining module (samchon/ttsc#1246). Files entering or
+ * leaving the project remain covered by the directory-membership snapshot,
+ * which is the one thing a content comparison cannot see. An envelope that
+ * declares no input set (a graph-free legacy host) passes `undefined` and keeps
+ * the whole-walk comparison.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys select relevant recorded content; legacy absence of that population requires exact key count and value equality for the full snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One comparison exposes narrowed and legacy-wide semantics without owning project enumeration or membership discovery.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant build artifacts cannot taint a declared generation, and narrowing never substitutes for the separate membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared-input scope, unrelated artifacts and the separate membership obligation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares recorded and current hash maps by key; it reads no filesystem and parses no path.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Key arrays are local to the comparison and no retained cache or native resource is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Declared comparison scans only its key set with early mismatch return; legacy comparison materializes both key arrays before checking left values. Property lookup and hash/signature equality include key and value text costs, while temporary key arrays grow with the full compared records. No file read or membership enumeration is repeated here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The generation validator decides whether this snapshot comparison may be shared; this helper computes one requested equality verdict.
+ */
+export declare function sameHashes(left: Record<string, string>, right: Record<string, string>, keys?: ReadonlySet<string>): boolean;

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

@@ -0,0 +1,25 @@
+/**
+ * Compare two project-walk snapshots.
+ *
+ * `keys` narrows the comparison to the generation's declared inputs. The walk
+ * hashes admitted regular files under the project root, but only a file the
+ * compile actually consumed can change an output, and a project root is a
+ * working directory: a framework's generated types, a log, a coverage report,
+ * or a test artifact appears and changes there while a compile runs. Comparing
+ * those would declare the generation incoherent and cost a whole-project
+ * recompile for every remaining module (samchon/ttsc#1246). Files entering or
+ * leaving the project remain covered by the directory-membership snapshot,
+ * which is the one thing a content comparison cannot see. An envelope that
+ * declares no input set (a graph-free legacy host) passes `undefined` and keeps
+ * the whole-walk comparison.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys select relevant recorded content; legacy absence of that population requires exact key count and value equality for the full snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One comparison exposes narrowed and legacy-wide semantics without owning project enumeration or membership discovery.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant build artifacts cannot taint a declared generation, and narrowing never substitutes for the separate membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared-input scope, unrelated artifacts and the separate membership obligation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares recorded and current hash maps by key; it reads no filesystem and parses no path.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Key arrays are local to the comparison and no retained cache or native resource is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Declared comparison scans only its key set with early mismatch return; legacy comparison materializes both key arrays before checking left values. Property lookup and hash/signature equality include key and value text costs, while temporary key arrays grow with the full compared records. No file read or membership enumeration is repeated here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The generation validator decides whether this snapshot comparison may be shared; this helper computes one requested equality verdict.
+ */
+export declare function sameHashes(left: Record<string, string>, right: Record<string, string>, keys?: ReadonlySet<string>): boolean;

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

@@ -0,0 +1,25 @@
+/**
+ * Compare two project-walk snapshots.
+ *
+ * `keys` narrows the comparison to the generation's declared inputs. The walk
+ * hashes admitted regular files under the project root, but only a file the
+ * compile actually consumed can change an output, and a project root is a
+ * working directory: a framework's generated types, a log, a coverage report,
+ * or a test artifact appears and changes there while a compile runs. Comparing
+ * those would declare the generation incoherent and cost a whole-project
+ * recompile for every remaining module (samchon/ttsc#1246). Files entering or
+ * leaving the project remain covered by the directory-membership snapshot,
+ * which is the one thing a content comparison cannot see. An envelope that
+ * declares no input set (a graph-free legacy host) passes `undefined` and keeps
+ * the whole-walk comparison.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys select relevant recorded content; legacy absence of that population requires exact key count and value equality for the full snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One comparison exposes narrowed and legacy-wide semantics without owning project enumeration or membership discovery.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant build artifacts cannot taint a declared generation, and narrowing never substitutes for the separate membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared-input scope, unrelated artifacts and the separate membership obligation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares recorded and current hash maps by key; it reads no filesystem and parses no path.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Key arrays are local to the comparison and no retained cache or native resource is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Declared comparison scans only its key set with early mismatch return; legacy comparison materializes both key arrays before checking left values. Property lookup and hash/signature equality include key and value text costs, while temporary key arrays grow with the full compared records. No file read or membership enumeration is repeated here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The generation validator decides whether this snapshot comparison may be shared; this helper computes one requested equality verdict.
+ */
+export declare function sameHashes(left: Record<string, string>, right: Record<string, string>, keys?: ReadonlySet<string>): boolean;

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

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Compare two project-walk snapshots.
+ *
+ * `keys` narrows the comparison to the generation's declared inputs. The walk
+ * hashes admitted regular files under the project root, but only a file the
+ * compile actually consumed can change an output, and a project root is a
+ * working directory: a framework's generated types, a log, a coverage report,
+ * or a test artifact appears and changes there while a compile runs. Comparing
+ * those would declare the generation incoherent and cost a whole-project
+ * recompile for every remaining module (samchon/ttsc#1246). Files entering or
+ * leaving the project remain covered by the directory-membership snapshot,
+ * which is the one thing a content comparison cannot see. An envelope that
+ * declares no input set (a graph-free legacy host) passes `undefined` and keeps
+ * the whole-walk comparison.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys select relevant recorded content; legacy absence of that population requires exact key count and value equality for the full snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One comparison exposes narrowed and legacy-wide semantics without owning project enumeration or membership discovery.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant build artifacts cannot taint a declared generation, and narrowing never substitutes for the separate membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared-input scope, unrelated artifacts and the separate membership obligation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares recorded and current hash maps by key; it reads no filesystem and parses no path.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Key arrays are local to the comparison and no retained cache or native resource is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Declared comparison scans only its key set with early mismatch return; legacy comparison materializes both key arrays before checking left values. Property lookup and hash/signature equality include key and value text costs, while temporary key arrays grow with the full compared records. No file read or membership enumeration is repeated here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The generation validator decides whether this snapshot comparison may be shared; this helper computes one requested equality verdict.
+ */
+function sameHashes(left, right, keys) {
+    if (keys !== undefined) {
+        for (const key of keys) {
+            if (left[key] !== right[key])
+                return false;
+        }
+        return true;
+    }
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => right[key] === left[key]);
+}
+
+exports.sameHashes = sameHashes;
+//# sourceMappingURL=sameHashes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sameHashes.js","sources":["../../../../src/core/transform/validation/sameHashes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;SACa,UAAU,CACxB,IAA4B,EAC5B,KAA6B,EAC7B,IAA0B,EAAA;AAE1B,IAAA,IAAI,IAAI,KAAK,SAAS,EAAE;AACtB,QAAA,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC;AAAE,gBAAA,OAAO,KAAK;QAC5C;AACA,QAAA,OAAO,IAAI;IACb;IACA,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IAClC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;IACpC,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,EAAE;AACxC,QAAA,OAAO,KAAK;IACd;AACA,IAAA,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D;;;;"}

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

@@ -0,0 +1,42 @@
+/**
+ * Compare two project-walk snapshots.
+ *
+ * `keys` narrows the comparison to the generation's declared inputs. The walk
+ * hashes admitted regular files under the project root, but only a file the
+ * compile actually consumed can change an output, and a project root is a
+ * working directory: a framework's generated types, a log, a coverage report,
+ * or a test artifact appears and changes there while a compile runs. Comparing
+ * those would declare the generation incoherent and cost a whole-project
+ * recompile for every remaining module (samchon/ttsc#1246). Files entering or
+ * leaving the project remain covered by the directory-membership snapshot,
+ * which is the one thing a content comparison cannot see. An envelope that
+ * declares no input set (a graph-free legacy host) passes `undefined` and keeps
+ * the whole-walk comparison.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys select relevant recorded content; legacy absence of that population requires exact key count and value equality for the full snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design One comparison exposes narrowed and legacy-wide semantics without owning project enumeration or membership discovery.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Irrelevant build artifacts cannot taint a declared generation, and narrowing never substitutes for the separate membership proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain declared-input scope, unrelated artifacts and the separate membership obligation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares recorded and current hash maps by key; it reads no filesystem and parses no path.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Key arrays are local to the comparison and no retained cache or native resource is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Declared comparison scans only its key set with early mismatch return; legacy comparison materializes both key arrays before checking left values. Property lookup and hash/signature equality include key and value text costs, while temporary key arrays grow with the full compared records. No file read or membership enumeration is repeated here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The generation validator decides whether this snapshot comparison may be shared; this helper computes one requested equality verdict.
+ */
+function sameHashes(left, right, keys) {
+    if (keys !== undefined) {
+        for (const key of keys) {
+            if (left[key] !== right[key])
+                return false;
+        }
+        return true;
+    }
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => right[key] === left[key]);
+}
+
+export { sameHashes };
+//# sourceMappingURL=sameHashes.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sameHashes.mjs","sources":["../../../../src/core/transform/validation/sameHashes.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;SACa,UAAU,CACxB,IAA4B,EAC5B,KAA6B,EAC7B,IAA0B,EAAA;AAE1B,IAAA,IAAI,IAAI,KAAK,SAAS,EAAE;AACtB,QAAA,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC;AAAE,gBAAA,OAAO,KAAK;QAC5C;AACA,QAAA,OAAO,IAAI;IACb;IACA,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IAClC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;IACpC,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,EAAE;AACxC,QAAA,OAAO,KAAK;IACd;AACA,IAAA,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D;;;;"}

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

@@ -0,0 +1,17 @@
+import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot.cjs";
+/**
+ * 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.d.mts

@@ -0,0 +1,17 @@
+import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot.mjs";
+/**
+ * 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.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;;;;"}