@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,55 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/**
+ * Validate a cached project transform against the current on-disk project
+ * state.
+ *
+ * A module with a recorded source compares its delivered text with the
+ * generation snapshot. An unrelated module outside an unchanged program needs
+ * no source comparison. A cache with a delivery epoch can use that comparison
+ * alone for a stable generation's first delivery of each module in the current
+ * pass, once the pass's own first delivery has proven the whole generation
+ * still matches the filesystem. An incomplete generation may not take this
+ * shortcut: otherwise a sibling output captured during a filesystem race could
+ * still be served once. Later graph-bearing requests validate the file's
+ * derived input set and project membership. A failed result is a diagnostic of
+ * the whole loaded program, so its repair cannot be proved by one delivered
+ * output's dependency closure. Failed and graph-free envelopes conservatively
+ * validate the complete project and out-of-walk snapshots, reusing qualified
+ * signatures. A mismatch rejects this generation for the delivery; its caller
+ * chooses replacement or capture. Delivered text that differs while the disk
+ * still holds the bytes the generation compiled is not one: it is reported and
+ * served, since the compile read the disk (samchon/ttsc#1394).
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
+ * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Epoch updates clear the generation's served checkpoint Set; the delivery
+ *   marker owns insertion and its unique-identity/text growth. Lazy output and
+ *   native identity indexes follow the generation's output/path population,
+ *   while validators replace current signature/directory witnesses. No new
+ *   independent handle or historical epoch collection is acquired here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   hash delivered text and divergent paths read/hash host bytes; unrelated
+ *   absent outputs can return before that hash after an initial K-output index.
+ *   Epoch-qualified first checkpoints share the complete proof. Other paths
+ *   pay derived-input or complete project/external/universal proof costs,
+ *   including path/byte populations, native observations and clock refresh.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ */
+export declare function matchesCachedSource(
+/** Generation retaining recorded baselines and distinct proof authority. */
+cached: TtscCachedProjectTransform, 
+/** Actual filesystem address whose identity and program role are tested. */
+file: string, 
+/** Delivered text, compared with the recorded baseline rather than adopted. */
+source: string, 
+/** Current host pass, or undefined for persistent input validation. */
+epoch: number | undefined): boolean;

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

@@ -0,0 +1,55 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/**
+ * Validate a cached project transform against the current on-disk project
+ * state.
+ *
+ * A module with a recorded source compares its delivered text with the
+ * generation snapshot. An unrelated module outside an unchanged program needs
+ * no source comparison. A cache with a delivery epoch can use that comparison
+ * alone for a stable generation's first delivery of each module in the current
+ * pass, once the pass's own first delivery has proven the whole generation
+ * still matches the filesystem. An incomplete generation may not take this
+ * shortcut: otherwise a sibling output captured during a filesystem race could
+ * still be served once. Later graph-bearing requests validate the file's
+ * derived input set and project membership. A failed result is a diagnostic of
+ * the whole loaded program, so its repair cannot be proved by one delivered
+ * output's dependency closure. Failed and graph-free envelopes conservatively
+ * validate the complete project and out-of-walk snapshots, reusing qualified
+ * signatures. A mismatch rejects this generation for the delivery; its caller
+ * chooses replacement or capture. Delivered text that differs while the disk
+ * still holds the bytes the generation compiled is not one: it is reported and
+ * served, since the compile read the disk (samchon/ttsc#1394).
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
+ * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Epoch updates clear the generation's served checkpoint Set; the delivery
+ *   marker owns insertion and its unique-identity/text growth. Lazy output and
+ *   native identity indexes follow the generation's output/path population,
+ *   while validators replace current signature/directory witnesses. No new
+ *   independent handle or historical epoch collection is acquired here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   hash delivered text and divergent paths read/hash host bytes; unrelated
+ *   absent outputs can return before that hash after an initial K-output index.
+ *   Epoch-qualified first checkpoints share the complete proof. Other paths
+ *   pay derived-input or complete project/external/universal proof costs,
+ *   including path/byte populations, native observations and clock refresh.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ */
+export declare function matchesCachedSource(
+/** Generation retaining recorded baselines and distinct proof authority. */
+cached: TtscCachedProjectTransform, 
+/** Actual filesystem address whose identity and program role are tested. */
+file: string, 
+/** Delivered text, compared with the recorded baseline rather than adopted. */
+source: string, 
+/** Current host pass, or undefined for persistent input validation. */
+epoch: number | undefined): boolean;

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

@@ -0,0 +1,55 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/**
+ * Validate a cached project transform against the current on-disk project
+ * state.
+ *
+ * A module with a recorded source compares its delivered text with the
+ * generation snapshot. An unrelated module outside an unchanged program needs
+ * no source comparison. A cache with a delivery epoch can use that comparison
+ * alone for a stable generation's first delivery of each module in the current
+ * pass, once the pass's own first delivery has proven the whole generation
+ * still matches the filesystem. An incomplete generation may not take this
+ * shortcut: otherwise a sibling output captured during a filesystem race could
+ * still be served once. Later graph-bearing requests validate the file's
+ * derived input set and project membership. A failed result is a diagnostic of
+ * the whole loaded program, so its repair cannot be proved by one delivered
+ * output's dependency closure. Failed and graph-free envelopes conservatively
+ * validate the complete project and out-of-walk snapshots, reusing qualified
+ * signatures. A mismatch rejects this generation for the delivery; its caller
+ * chooses replacement or capture. Delivered text that differs while the disk
+ * still holds the bytes the generation compiled is not one: it is reported and
+ * served, since the compile read the disk (samchon/ttsc#1394).
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
+ * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Epoch updates clear the generation's served checkpoint Set; the delivery
+ *   marker owns insertion and its unique-identity/text growth. Lazy output and
+ *   native identity indexes follow the generation's output/path population,
+ *   while validators replace current signature/directory witnesses. No new
+ *   independent handle or historical epoch collection is acquired here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   hash delivered text and divergent paths read/hash host bytes; unrelated
+ *   absent outputs can return before that hash after an initial K-output index.
+ *   Epoch-qualified first checkpoints share the complete proof. Other paths
+ *   pay derived-input or complete project/external/universal proof costs,
+ *   including path/byte populations, native observations and clock refresh.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ */
+export declare function matchesCachedSource(
+/** Generation retaining recorded baselines and distinct proof authority. */
+cached: TtscCachedProjectTransform, 
+/** Actual filesystem address whose identity and program role are tested. */
+file: string, 
+/** Delivered text, compared with the recorded baseline rather than adopted. */
+source: string, 
+/** Current host pass, or undefined for persistent input validation. */
+epoch: number | undefined): boolean;

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

@@ -0,0 +1,155 @@
+'use strict';
+
+var matchesProjectRootFile = require('../../tsconfig/matchesProjectRootFile.js');
+var resultFilesystem = require('../cache/resultFilesystem.js');
+var TRANSFORM_CLOCK_REFERENCE_DIRECTORIES = require('../clock/TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.js');
+var refreshFilesystemClockReference = require('../clock/refreshFilesystemClockReference.js');
+var reportDivergentDelivery = require('../diagnostics/reportDivergentDelivery.js');
+var createEnvelopeKeyIndex = require('../envelope/createEnvelopeKeyIndex.js');
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var toProjectKey = require('../project/toProjectKey.js');
+var hashText = require('../utils/hashText.js');
+var matchesCompleteInputSnapshot = require('./matchesCompleteInputSnapshot.js');
+var matchesNarrowPersistentInputs = require('./matchesNarrowPersistentInputs.js');
+var nativeInputPredicatesHold = require('./nativeInputPredicatesHold.js');
+var notificationsProveProgramUnchanged = require('./notificationsProveProgramUnchanged.js');
+
+/**
+ * Validate a cached project transform against the current on-disk project
+ * state.
+ *
+ * A module with a recorded source compares its delivered text with the
+ * generation snapshot. An unrelated module outside an unchanged program needs
+ * no source comparison. A cache with a delivery epoch can use that comparison
+ * alone for a stable generation's first delivery of each module in the current
+ * pass, once the pass's own first delivery has proven the whole generation
+ * still matches the filesystem. An incomplete generation may not take this
+ * shortcut: otherwise a sibling output captured during a filesystem race could
+ * still be served once. Later graph-bearing requests validate the file's
+ * derived input set and project membership. A failed result is a diagnostic of
+ * the whole loaded program, so its repair cannot be proved by one delivered
+ * output's dependency closure. Failed and graph-free envelopes conservatively
+ * validate the complete project and out-of-walk snapshots, reusing qualified
+ * signatures. A mismatch rejects this generation for the delivery; its caller
+ * chooses replacement or capture. Delivered text that differs while the disk
+ * still holds the bytes the generation compiled is not one: it is reported and
+ * served, since the compile read the disk (samchon/ttsc#1394).
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
+ * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Epoch updates clear the generation's served checkpoint Set; the delivery
+ *   marker owns insertion and its unique-identity/text growth. Lazy output and
+ *   native identity indexes follow the generation's output/path population,
+ *   while validators replace current signature/directory witnesses. No new
+ *   independent handle or historical epoch collection is acquired here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   hash delivered text and divergent paths read/hash host bytes; unrelated
+ *   absent outputs can return before that hash after an initial K-output index.
+ *   Epoch-qualified first checkpoints share the complete proof. Other paths
+ *   pay derived-input or complete project/external/universal proof costs,
+ *   including path/byte populations, native observations and clock refresh.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ */
+function matchesCachedSource(
+/** Generation retaining recorded baselines and distinct proof authority. */
+cached, 
+/** Actual filesystem address whose identity and program role are tested. */
+file, 
+/** Delivered text, compared with the recorded baseline rather than adopted. */
+source, 
+/** Current host pass, or undefined for persistent input validation. */
+epoch) {
+    if (!nativeInputPredicatesHold.nativeInputPredicatesHold(cached))
+        return false;
+    if (cached.freshDeliveryOnly === true)
+        return false;
+    const identities = envelopeDerivation.envelopeDerivation(cached).identityContext;
+    const currentKey = toProjectKey.toProjectKey(cached.projectRoot, file, identities);
+    const identity = pathIdentityKey.pathIdentityKey(file, identities);
+    const expected = cached.sourceHashes?.[identity] ??
+        (Object.prototype.hasOwnProperty.call(cached.inputHashes, currentKey)
+            ? cached.inputHashes[currentKey]
+            : undefined) ??
+        cached.externalInputHashes?.[identity];
+    if (expected === undefined &&
+        cached.result.type === "success" &&
+        !matchesProjectRootFile.matchesProjectRootFile(file, cached.membershipPolicy, false, resultFilesystem.resultFilesystem(cached.result).platform)) {
+        const state = envelopeDerivation.envelopeDerivation(cached);
+        const outputs = (state.outputIndex ??= createEnvelopeKeyIndex.createEnvelopeKeyIndex(state, cached.projectRoot, Object.fromEntries(Object.keys(cached.result.typescript).map((entry) => [entry, entry]))));
+        if (!outputs.has(identity)) {
+            // While the watchers prove the program unchanged, the module is still
+            // outside it, and no walk is needed to say so (samchon/ttsc#1398).
+            if (notificationsProveProgramUnchanged.notificationsProveProgramUnchanged(cached)) {
+                return true;
+            }
+            // Root discovery deliberately never hashed this unrelated module. Its
+            // bytes cannot affect an output the compiler did not produce, but the
+            // whole program must still be current before we reuse that absence: a
+            // changed config or importer can bring this file into the next program.
+            refreshFilesystemClockReference.refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem.resultFilesystem(cached.result));
+            return matchesCompleteInputSnapshot.matchesCompleteInputSnapshot(cached);
+        }
+    }
+    if (expected !== hashText.hashText(source)) {
+        // The generation compiled the file from disk. When the disk still holds
+        // exactly those bytes, the delivered text came from somewhere else, a
+        // plugin ordered before ttsc or a read that raced an edit, and cannot
+        // change the output; recompiling for it would repeat on every delivery
+        // (samchon/ttsc#1394).
+        if (expected === undefined ||
+            hostInputStateHash.hostInputStateHash(file, resultFilesystem.resultFilesystem(cached.result)) !== expected) {
+            return false;
+        }
+        reportDivergentDelivery.reportDivergentDelivery(cached, file);
+    }
+    if (epoch !== undefined && cached.projectSnapshotComplete === true) {
+        if (cached.deliveryEpoch !== epoch) {
+            // The pass's first delivery. The generation was settled against an
+            // earlier pass, so prove the whole of it once — every input the envelope
+            // declares, the directory membership, the universal host inputs, and the
+            // out-of-walk snapshot — before any of this pass's deliveries may be
+            // settled against it. That proof is what a per-pass recompile used to buy
+            // (samchon/ttsc#1300), at a walk instead of a compile.
+            refreshFilesystemClockReference.refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem.resultFilesystem(cached.result));
+            if (!matchesCompleteInputSnapshot.matchesCompleteInputSnapshot(cached)) {
+                return false;
+            }
+            cached.deliveryEpoch = epoch;
+            cached.servedFiles?.clear();
+            return true;
+        }
+        if (!cached.servedFiles?.has(identity)) {
+            return true;
+        }
+    }
+    refreshFilesystemClockReference.refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem.resultFilesystem(cached.result));
+    if (cached.result.type === "success" &&
+        cached.result.graph !== undefined &&
+        cached.projectSnapshotComplete === true &&
+        cached.projectDirectories !== undefined &&
+        cached.projectMutationTracker !== undefined &&
+        cached.hostInputMutationTracker !== undefined) {
+        const narrow = matchesNarrowPersistentInputs.matchesNarrowPersistentInputs(cached, file);
+        if (narrow !== undefined) {
+            return narrow;
+        }
+        // Notifications stopped proving membership after this generation was
+        // produced. Losing the proof is not evidence of a change, so fall through
+        // to the snapshot the entry still carries.
+    }
+    return matchesCompleteInputSnapshot.matchesCompleteInputSnapshot(cached);
+}
+
+exports.matchesCachedSource = matchesCachedSource;
+//# sourceMappingURL=matchesCachedSource.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesCachedSource.js","sources":["../../../../src/core/transform/validation/matchesCachedSource.ts"],"sourcesContent":[null],"names":["nativeInputPredicatesHold","envelopeDerivation","toProjectKey","pathIdentityKey","matchesProjectRootFile","resultFilesystem","createEnvelopeKeyIndex","notificationsProveProgramUnchanged","refreshFilesystemClockReference","TRANSFORM_CLOCK_REFERENCE_DIRECTORIES","matchesCompleteInputSnapshot","hashText","hostInputStateHash","reportDivergentDelivery","matchesNarrowPersistentInputs"],"mappings":"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"}

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

@@ -0,0 +1,153 @@
+import { matchesProjectRootFile } from '../../tsconfig/matchesProjectRootFile.mjs';
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { TRANSFORM_CLOCK_REFERENCE_DIRECTORIES } from '../clock/TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.mjs';
+import { refreshFilesystemClockReference } from '../clock/refreshFilesystemClockReference.mjs';
+import { reportDivergentDelivery } from '../diagnostics/reportDivergentDelivery.mjs';
+import { createEnvelopeKeyIndex } from '../envelope/createEnvelopeKeyIndex.mjs';
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { toProjectKey } from '../project/toProjectKey.mjs';
+import { hashText } from '../utils/hashText.mjs';
+import { matchesCompleteInputSnapshot } from './matchesCompleteInputSnapshot.mjs';
+import { matchesNarrowPersistentInputs } from './matchesNarrowPersistentInputs.mjs';
+import { nativeInputPredicatesHold } from './nativeInputPredicatesHold.mjs';
+import { notificationsProveProgramUnchanged } from './notificationsProveProgramUnchanged.mjs';
+
+/**
+ * Validate a cached project transform against the current on-disk project
+ * state.
+ *
+ * A module with a recorded source compares its delivered text with the
+ * generation snapshot. An unrelated module outside an unchanged program needs
+ * no source comparison. A cache with a delivery epoch can use that comparison
+ * alone for a stable generation's first delivery of each module in the current
+ * pass, once the pass's own first delivery has proven the whole generation
+ * still matches the filesystem. An incomplete generation may not take this
+ * shortcut: otherwise a sibling output captured during a filesystem race could
+ * still be served once. Later graph-bearing requests validate the file's
+ * derived input set and project membership. A failed result is a diagnostic of
+ * the whole loaded program, so its repair cannot be proved by one delivered
+ * output's dependency closure. Failed and graph-free envelopes conservatively
+ * validate the complete project and out-of-walk snapshots, reusing qualified
+ * signatures. A mismatch rejects this generation for the delivery; its caller
+ * chooses replacement or capture. Delivered text that differs while the disk
+ * still holds the bytes the generation compiled is not one: it is reported and
+ * served, since the compile read the disk (samchon/ttsc#1394).
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
+ * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Epoch updates clear the generation's served checkpoint Set; the delivery
+ *   marker owns insertion and its unique-identity/text growth. Lazy output and
+ *   native identity indexes follow the generation's output/path population,
+ *   while validators replace current signature/directory witnesses. No new
+ *   independent handle or historical epoch collection is acquired here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   hash delivered text and divergent paths read/hash host bytes; unrelated
+ *   absent outputs can return before that hash after an initial K-output index.
+ *   Epoch-qualified first checkpoints share the complete proof. Other paths
+ *   pay derived-input or complete project/external/universal proof costs,
+ *   including path/byte populations, native observations and clock refresh.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ */
+function matchesCachedSource(
+/** Generation retaining recorded baselines and distinct proof authority. */
+cached, 
+/** Actual filesystem address whose identity and program role are tested. */
+file, 
+/** Delivered text, compared with the recorded baseline rather than adopted. */
+source, 
+/** Current host pass, or undefined for persistent input validation. */
+epoch) {
+    if (!nativeInputPredicatesHold(cached))
+        return false;
+    if (cached.freshDeliveryOnly === true)
+        return false;
+    const identities = envelopeDerivation(cached).identityContext;
+    const currentKey = toProjectKey(cached.projectRoot, file, identities);
+    const identity = pathIdentityKey(file, identities);
+    const expected = cached.sourceHashes?.[identity] ??
+        (Object.prototype.hasOwnProperty.call(cached.inputHashes, currentKey)
+            ? cached.inputHashes[currentKey]
+            : undefined) ??
+        cached.externalInputHashes?.[identity];
+    if (expected === undefined &&
+        cached.result.type === "success" &&
+        !matchesProjectRootFile(file, cached.membershipPolicy, false, resultFilesystem(cached.result).platform)) {
+        const state = envelopeDerivation(cached);
+        const outputs = (state.outputIndex ??= createEnvelopeKeyIndex(state, cached.projectRoot, Object.fromEntries(Object.keys(cached.result.typescript).map((entry) => [entry, entry]))));
+        if (!outputs.has(identity)) {
+            // While the watchers prove the program unchanged, the module is still
+            // outside it, and no walk is needed to say so (samchon/ttsc#1398).
+            if (notificationsProveProgramUnchanged(cached)) {
+                return true;
+            }
+            // Root discovery deliberately never hashed this unrelated module. Its
+            // bytes cannot affect an output the compiler did not produce, but the
+            // whole program must still be current before we reuse that absence: a
+            // changed config or importer can bring this file into the next program.
+            refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem(cached.result));
+            return matchesCompleteInputSnapshot(cached);
+        }
+    }
+    if (expected !== hashText(source)) {
+        // The generation compiled the file from disk. When the disk still holds
+        // exactly those bytes, the delivered text came from somewhere else, a
+        // plugin ordered before ttsc or a read that raced an edit, and cannot
+        // change the output; recompiling for it would repeat on every delivery
+        // (samchon/ttsc#1394).
+        if (expected === undefined ||
+            hostInputStateHash(file, resultFilesystem(cached.result)) !== expected) {
+            return false;
+        }
+        reportDivergentDelivery(cached, file);
+    }
+    if (epoch !== undefined && cached.projectSnapshotComplete === true) {
+        if (cached.deliveryEpoch !== epoch) {
+            // The pass's first delivery. The generation was settled against an
+            // earlier pass, so prove the whole of it once — every input the envelope
+            // declares, the directory membership, the universal host inputs, and the
+            // out-of-walk snapshot — before any of this pass's deliveries may be
+            // settled against it. That proof is what a per-pass recompile used to buy
+            // (samchon/ttsc#1300), at a walk instead of a compile.
+            refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem(cached.result));
+            if (!matchesCompleteInputSnapshot(cached)) {
+                return false;
+            }
+            cached.deliveryEpoch = epoch;
+            cached.servedFiles?.clear();
+            return true;
+        }
+        if (!cached.servedFiles?.has(identity)) {
+            return true;
+        }
+    }
+    refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem(cached.result));
+    if (cached.result.type === "success" &&
+        cached.result.graph !== undefined &&
+        cached.projectSnapshotComplete === true &&
+        cached.projectDirectories !== undefined &&
+        cached.projectMutationTracker !== undefined &&
+        cached.hostInputMutationTracker !== undefined) {
+        const narrow = matchesNarrowPersistentInputs(cached, file);
+        if (narrow !== undefined) {
+            return narrow;
+        }
+        // Notifications stopped proving membership after this generation was
+        // produced. Losing the proof is not evidence of a change, so fall through
+        // to the snapshot the entry still carries.
+    }
+    return matchesCompleteInputSnapshot(cached);
+}
+
+export { matchesCachedSource };
+//# sourceMappingURL=matchesCachedSource.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesCachedSource.mjs","sources":["../../../../src/core/transform/validation/matchesCachedSource.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

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

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/**
+ * Prove one generation from its own recorded snapshot, with no help from live
+ * notifications.
+ *
+ * This is the fallback for a graph-free envelope and for a generation whose
+ * watchers could not be opened or have since failed: losing the notification
+ * proof must cost the narrow path, not the cache. The walk re-proves membership
+ * directly — the recorded directory signatures plus the recorded file-key
+ * universe — so a created, deleted, or renamed input still invalidates without
+ * any watcher.
+ *
+ * The delivered module is compared from disk like every other input: the
+ * compile read it from disk, so a delivered text that differs is not the file's
+ * state (samchon/ttsc#1394). The delivery caller refreshes the generation's
+ * native clock reference before this operation; this validator does not mint a
+ * reference itself.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal authority, declared project membership, content hashes and external physical targets must all match before project/external signatures and directory observations are adopted. Universal entry validators may independently refresh already qualified entry witnesses along the way.
+ * @evidence contracts/common.md#clear-and-simple-design One complete-proof boundary composes domain validators and adopts aggregate project/external witnesses after combined success, while universal entry qualification stays with its owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed notifications neither prove unchanged state nor force recompilation when direct recorded-state validation can establish the same generation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lost-notification fallback, membership authority, disk-source comparison and the reason signatures are re-earned.
+ * @evidence contracts/portability.md#os-neutral-implementation The recorded compiler membership policy and identity context qualify the native walk and lexical alias targets rather than assumed OS case rules.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Current directory observations are replaced; earned signatures merge into generation records, which may retain older entries rather than deleting every unearned witness. Storage follows that generation's directory/input spelling population and lazy identity/selection indexes, without an independent historical snapshot collection or new watcher handle here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Universal entries/probes/tree environments precede a native membership
+ *   walk. Declared keys avoid irrelevant byte hashes but do not skip directory
+ *   enumeration. Directory/hash comparisons, external spelling and physical
+ *   target scans, signature entry materialization/adoption and native identity
+ *   work add population/path/digit costs; unresolved content and predicate
+ *   replay add bytes/listings. Early rejection skips subsequent domains.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  Qualified separable signatures avoid repeated content reads under the caller's refreshed clock. Successful aggregate proof adopts earned project/external signatures and clears unverified flags; it neither clears recorded changes/failed flags nor makes later quiet notifications sufficient without their other admission conditions.
+ */
+export declare function matchesCompleteInputSnapshot(
+/**
+ * Generation with a complete capture baseline and caller-refreshed clock
+ * proof.
+ */
+cached: TtscCachedProjectTransform): boolean;

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

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/**
+ * Prove one generation from its own recorded snapshot, with no help from live
+ * notifications.
+ *
+ * This is the fallback for a graph-free envelope and for a generation whose
+ * watchers could not be opened or have since failed: losing the notification
+ * proof must cost the narrow path, not the cache. The walk re-proves membership
+ * directly — the recorded directory signatures plus the recorded file-key
+ * universe — so a created, deleted, or renamed input still invalidates without
+ * any watcher.
+ *
+ * The delivered module is compared from disk like every other input: the
+ * compile read it from disk, so a delivered text that differs is not the file's
+ * state (samchon/ttsc#1394). The delivery caller refreshes the generation's
+ * native clock reference before this operation; this validator does not mint a
+ * reference itself.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal authority, declared project membership, content hashes and external physical targets must all match before project/external signatures and directory observations are adopted. Universal entry validators may independently refresh already qualified entry witnesses along the way.
+ * @evidence contracts/common.md#clear-and-simple-design One complete-proof boundary composes domain validators and adopts aggregate project/external witnesses after combined success, while universal entry qualification stays with its owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed notifications neither prove unchanged state nor force recompilation when direct recorded-state validation can establish the same generation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lost-notification fallback, membership authority, disk-source comparison and the reason signatures are re-earned.
+ * @evidence contracts/portability.md#os-neutral-implementation The recorded compiler membership policy and identity context qualify the native walk and lexical alias targets rather than assumed OS case rules.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Current directory observations are replaced; earned signatures merge into generation records, which may retain older entries rather than deleting every unearned witness. Storage follows that generation's directory/input spelling population and lazy identity/selection indexes, without an independent historical snapshot collection or new watcher handle here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Universal entries/probes/tree environments precede a native membership
+ *   walk. Declared keys avoid irrelevant byte hashes but do not skip directory
+ *   enumeration. Directory/hash comparisons, external spelling and physical
+ *   target scans, signature entry materialization/adoption and native identity
+ *   work add population/path/digit costs; unresolved content and predicate
+ *   replay add bytes/listings. Early rejection skips subsequent domains.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  Qualified separable signatures avoid repeated content reads under the caller's refreshed clock. Successful aggregate proof adopts earned project/external signatures and clears unverified flags; it neither clears recorded changes/failed flags nor makes later quiet notifications sufficient without their other admission conditions.
+ */
+export declare function matchesCompleteInputSnapshot(
+/**
+ * Generation with a complete capture baseline and caller-refreshed clock
+ * proof.
+ */
+cached: TtscCachedProjectTransform): boolean;

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

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/**
+ * Prove one generation from its own recorded snapshot, with no help from live
+ * notifications.
+ *
+ * This is the fallback for a graph-free envelope and for a generation whose
+ * watchers could not be opened or have since failed: losing the notification
+ * proof must cost the narrow path, not the cache. The walk re-proves membership
+ * directly — the recorded directory signatures plus the recorded file-key
+ * universe — so a created, deleted, or renamed input still invalidates without
+ * any watcher.
+ *
+ * The delivered module is compared from disk like every other input: the
+ * compile read it from disk, so a delivered text that differs is not the file's
+ * state (samchon/ttsc#1394). The delivery caller refreshes the generation's
+ * native clock reference before this operation; this validator does not mint a
+ * reference itself.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal authority, declared project membership, content hashes and external physical targets must all match before project/external signatures and directory observations are adopted. Universal entry validators may independently refresh already qualified entry witnesses along the way.
+ * @evidence contracts/common.md#clear-and-simple-design One complete-proof boundary composes domain validators and adopts aggregate project/external witnesses after combined success, while universal entry qualification stays with its owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed notifications neither prove unchanged state nor force recompilation when direct recorded-state validation can establish the same generation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lost-notification fallback, membership authority, disk-source comparison and the reason signatures are re-earned.
+ * @evidence contracts/portability.md#os-neutral-implementation The recorded compiler membership policy and identity context qualify the native walk and lexical alias targets rather than assumed OS case rules.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Current directory observations are replaced; earned signatures merge into generation records, which may retain older entries rather than deleting every unearned witness. Storage follows that generation's directory/input spelling population and lazy identity/selection indexes, without an independent historical snapshot collection or new watcher handle here.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
+ *   Universal entries/probes/tree environments precede a native membership
+ *   walk. Declared keys avoid irrelevant byte hashes but do not skip directory
+ *   enumeration. Directory/hash comparisons, external spelling and physical
+ *   target scans, signature entry materialization/adoption and native identity
+ *   work add population/path/digit costs; unresolved content and predicate
+ *   replay add bytes/listings. Early rejection skips subsequent domains.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  Qualified separable signatures avoid repeated content reads under the caller's refreshed clock. Successful aggregate proof adopts earned project/external signatures and clears unverified flags; it neither clears recorded changes/failed flags nor makes later quiet notifications sufficient without their other admission conditions.
+ */
+export declare function matchesCompleteInputSnapshot(
+/**
+ * Generation with a complete capture baseline and caller-refreshed clock
+ * proof.
+ */
+cached: TtscCachedProjectTransform): boolean;