@ttsc/unplugin 0.34.3 → 0.36.0

package/src/core/transform/deliverCachedTransform.ts

@@ -66,6 +66,7 @@ export function deliverCachedTransform(props: {
       epoch,
       hooks,
     );
+    if (cached.snapshotDeliveryOnly === true) hooks?.markVolatile?.();
     reportSuccessDiagnostics(cached, epoch);
     let output;
     try {
@@ -90,7 +91,10 @@ export function deliverCachedTransform(props: {
     notifyVolatileDelivery(hooks, cached, file);
     return createTransformResult(file, source, output);
   } catch (error) {
-    if (cached.freshDeliveryOnly === true)
+    if (
+      cached.freshDeliveryOnly === true ||
+      cached.snapshotDeliveryOnly === true
+    )
       evictGeneration(cache, key, generation);
     throw error;
   }

package/src/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.ts

@@ -0,0 +1,31 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from "./DEFAULT_FILESYSTEM_OPERATIONS";
+import type { TtscTransformFilesystemOperations } from "./TtscTransformFilesystemOperations";
+
+/**
+ * Establish that a consumer observes the native input view its compiler used. A
+ * copied default table preserves that authority; substituted input operations
+ * have no equivalent-view certificate. Watch callbacks do not replace inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Every frozen native input capability must retain its reference and native path/case policy must remain selected; this connects the consumer view to native compiler reads before freshness-only delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One predicate checks the existing operation table without adding a claimed-equivalence option or probing filesystem contents.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown wrappers and unavailable capabilities retain ordinary proof rather than borrowing native authority; no plugin, path or test identity determines admission.
+ * @evidence contracts/common.md#meaningful-documentation Prose distinguishes copied tables, substituted input operations and independent watch callbacks.
+ * @evidence contracts/portability.md#os-neutral-implementation Actual native operation references establish input semantics; an explicit path dialect must match the current process and a supplied case-policy implementation remains uncertified. No OS name establishes a volume's case behavior.
+ * @evidence contracts/performance.md#efficient-algorithms One fixed native-operation table is enumerated and references are compared; no input paths, source bytes or capabilities are queried.
+ * @evidence contracts/performance.md#reuse-equivalent-work The frozen default capabilities are borrowed across calls, while the supplied view is checked afresh without retaining a verdict across possible changes.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources A fixed call-local entry array follows the synchronous comparison; no input history, callback ownership or native handle is retained.
+ */
+export function matchesNativeCompilerSnapshotFilesystem(
+  filesystem: TtscTransformFilesystemOperations,
+): boolean {
+  if (
+    filesystem.caseSensitive !== undefined ||
+    (filesystem.platform !== undefined &&
+      filesystem.platform !== process.platform)
+  )
+    return false;
+  return Object.entries(DEFAULT_FILESYSTEM_OPERATIONS).every(
+    ([name, operation]) =>
+      filesystem[name as keyof TtscTransformFilesystemOperations] === operation,
+  );
+}

package/src/core/transform/generation/TtscGenerationProofFailures.ts

@@ -24,6 +24,27 @@ export interface TtscGenerationProofFailures {
   /** Unique witnesses kept, at most `MAX_GENERATION_PROOF_FAILURES`. */
   entries: TtscGenerationProofFailure[];
 
+  /**
+   * Complete streaming classification, including witnesses omitted from
+   * diagnostics.
+   */
+  snapshotCompatible?: boolean;
+
+  /**
+   * Borrowed generation-owned classifier, absent without a captured native
+   * view.
+   *
+   * @evidence contracts/common.md#principled-implementation The sticky compatibility verdict accounts for every occurrence before diagnostic truncation; after its first refusal no later occurrence can restore delivery authority.
+   * @evidence contracts/common.md#clear-and-simple-design Collectors borrow one generation classifier rather than rebuilding its recorded-input index.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The callback records compatibility only; callers still require complete producer proof and never infer cache freshness from it.
+   * @evidence contracts/common.md#meaningful-documentation The member states optionality and ownership, while the generation classifier documents actual path and kind admission.
+   * @evidence contracts/portability.md#os-neutral-implementation The callback receives native lexical witness paths and delegates their interpretation to the generation's classifier.
+   * @evidenceExclude contracts/performance.md#efficient-algorithms This signature declares no runtime computation; the classifier implementation owns its index and lookup costs.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work This signature declares no memo; generation capture owns sharing the callback.
+   * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This signature acquires no resource; generation capture owns the borrowed closure's lifetime.
+   */
+  snapshotFailureClassifier?: (failure: TtscGenerationProofFailure) => boolean;
+
   /** Saturated count of further witness occurrences dropped after the bound. */
   omitted: number;
 

package/src/core/transform/generation/canDeliverCompilerSnapshot.ts

@@ -0,0 +1,50 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+
+import { resultFilesystem } from "../cache/resultFilesystem";
+import { matchesNativeCompilerSnapshotFilesystem } from "../filesystem/matchesNativeCompilerSnapshotFilesystem";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+import { compilerSnapshotFailureClassifier } from "./compilerSnapshotFailureClassifier";
+
+/**
+ * Separate a coherent local compiler result from proof that disk still matches
+ * it. Only recorded compiler inputs and project changes may lose freshness;
+ * missing, contradictory or unobserved producer inputs remain refusals. Adopted
+ * results must be current on this worker before they can be delivered. The
+ * consumer must retain the native input view; a substituted filesystem cannot
+ * classify its disagreement with the compiler as a physical source edit.
+ *
+ * @evidence contracts/common.md#principled-implementation A native shared snapshot ID, matching native consumer input capabilities, internally consistent graph and complete host observation establish current-generation authority; only explicit freshness changes covered by that graph can bypass stabilization.
+ * @evidence contracts/common.md#clear-and-simple-design One admission predicate separates delivery from existing cache/publication validation without weakening those validators.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown failure kinds, incomplete reports, foreign adoptions and producer conflicts cannot become a successful snapshot delivery.
+ * @evidence contracts/common.md#meaningful-documentation Prose distinguishes local authority, disk freshness and adopted-worker requirements.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve maps compiler-relative proof keys to their project anchor; the consumer gate compares actual native input capabilities and explicit path grammar; this predicate infers no case or physical identity from OS names.
+ * @evidence contracts/performance.md#efficient-algorithms A fixed native capability comparison establishes the observing view before any summary is trusted. A captured streaming summary then answers without another scan; legacy caller aggregates with no omissions use one recorded-input classifier and a bounded witness scan. Native disk inputs are not reread.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Delivery permission does not grant cache or publication reuse and is recomputed for each captured result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Call-local indexes retain no handle or generation history.
+ */
+export function canDeliverCompilerSnapshot(props: {
+  result: ITtscCompilerTransformation;
+  projectRoot: string;
+  failures: TtscGenerationProofFailures;
+  adopted: boolean;
+}): boolean {
+  const { result, failures } = props;
+  if (
+    props.adopted ||
+    result.type !== "success" ||
+    !result.graph?.compilationSnapshot ||
+    !matchesNativeCompilerSnapshotFilesystem(resultFilesystem(result)) ||
+    result.observationsComplete === false ||
+    Object.keys(result.hostInputProofFailures ?? {}).length !== 0 ||
+    Object.keys(result.graph.inputProofFailures ?? {}).length !== 0 ||
+    failures.entries.length === 0
+  )
+    return false;
+  if (failures.snapshotCompatible !== undefined)
+    return failures.snapshotCompatible;
+  const classify = compilerSnapshotFailureClassifier(
+    result,
+    props.projectRoot,
+  )!;
+  return failures.omitted === 0 && failures.entries.every(classify);
+}

package/src/core/transform/generation/captureTransformGeneration.ts

@@ -12,6 +12,8 @@ import { TRANSFORM_RESULT_MEMBERSHIP } from "../cache/TRANSFORM_RESULT_MEMBERSHI
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
 import { refreshFilesystemClockReference } from "../clock/refreshFilesystemClockReference";
 import { reportDivergentDelivery } from "../diagnostics/reportDivergentDelivery";
+import { envelopeDerivation } from "../envelope/envelopeDerivation";
+import { envelopeGraphIndexes } from "../envelope/envelopeGraphIndexes";
 import { generationCaseSensitivity } from "../envelope/generationCaseSensitivity";
 import { selectDeclaredProjectInputKeys } from "../envelope/selectDeclaredProjectInputKeys";
 import { selectExternalInputPaths } from "../envelope/selectExternalInputPaths";
@@ -49,8 +51,10 @@ import { witnessExternalDependencies } from "../validation/witnessExternalDepend
 import { TRANSFORM_FAILED_GENERATION_VALIDATIONS } from "./TRANSFORM_FAILED_GENERATION_VALIDATIONS";
 import { TRANSFORM_GENERATION_FAILURES } from "./TRANSFORM_GENERATION_FAILURES";
 import type { TtscCompilerMembershipHint } from "./TtscCompilerMembershipHint";
+import { canDeliverCompilerSnapshot } from "./canDeliverCompilerSnapshot";
 import { captureFailedGenerationInputStates } from "./captureFailedGenerationInputStates";
 import { captureTransformSourceHashes } from "./captureTransformSourceHashes";
+import { compilerSnapshotFailureClassifier } from "./compilerSnapshotFailureClassifier";
 import { createGenerationProofFailures } from "./createGenerationProofFailures";
 import { mergeGenerationProofFailures } from "./mergeGenerationProofFailures";
 import { primeCompilerMembership } from "./primeCompilerMembership";
@@ -655,8 +659,9 @@ export async function captureTransformGeneration(props: {
       hostInputTracker,
       candidateTracker,
     );
-    // The compile read this file from disk, so the disk's bytes are its state in
-    // this generation. A delivered text that differs, because a plugin ordered
+    // Ordinary stable captures use the disk baseline below; snapshot-only
+    // delivery later replaces it with the compiler's captured source hash.
+    // Delivered text that differs, because a plugin ordered
     // before ttsc rewrote the module or the file changed after the host read
     // it, must not replace them: every sibling delivery compares the disk and
     // would recompile the project (samchon/ttsc#1394). An actual delivery is reported once
@@ -711,21 +716,15 @@ export async function captureTransformGeneration(props: {
         ? {}
         : { temporaryTsconfig: envelopeTemporaryTsconfig }),
     };
+    cached.snapshotFailureClassifier = compilerSnapshotFailureClassifier(
+      result,
+      projectRoot,
+    );
     cached.sourceHashes = captureTransformSourceHashes(
       cached,
       props.currentFile,
       diskHash ?? deliveredHash,
     );
-    // Preparation reads native source only to seed the ordinary capture. A
-    // later edit is handled by generation proof, not a warning about a host
-    // rewrite: no host delivered that speculative module (#1764).
-    if (
-      props.reportDivergence !== false &&
-      diskHash !== undefined &&
-      diskHash !== deliveredHash
-    ) {
-      reportDivergentDelivery(cached, props.currentFile);
-    }
     // An adopted compile was certified by its publisher, and is matched below
     // against the state that publisher recorded.
     const externalInputSnapshot = captureExternalInputSnapshot(
@@ -764,7 +763,9 @@ export async function captureTransformGeneration(props: {
     // Evaluate every proof family rather than short-circuiting after the first
     // failed one, so a rejected generation reports every missing premise. The
     // same checks establish a successful generation's reuse authority.
-    const failures = createGenerationProofFailures();
+    const failures = createGenerationProofFailures(
+      cached.snapshotFailureClassifier,
+    );
     if (!configStable) {
       recordGenerationProofFailure(failures, {
         domain: "project",
@@ -828,6 +829,33 @@ export async function captureTransformGeneration(props: {
       externalInputSnapshot.complete &&
       adoptionFailure === undefined &&
       universalInputs;
+    const snapshotDeliveryOnly =
+      !stableProjectSnapshot &&
+      canDeliverCompilerSnapshot({
+        result,
+        projectRoot,
+        failures,
+        adopted: adopted !== undefined,
+      });
+    const capturedSource = snapshotDeliveryOnly
+      ? envelopeGraphIndexes(
+          envelopeDerivation(cached),
+          cached,
+        ).inputObservations.get(path.resolve(props.currentFile))?.readFile
+      : undefined;
+    // A source save between the compiler read and the postcompile walk is not
+    // proof of an earlier host rewrite. For a raced snapshot, report one only
+    // when the compiler and disk still agree on this module's source content.
+    if (
+      props.reportDivergence !== false &&
+      diskHash !== undefined &&
+      diskHash !== deliveredHash &&
+      (!snapshotDeliveryOnly ||
+        (before.hashes[currentFileKey] === diskHash &&
+          capturedSource?.ok === true &&
+          capturedSource.hash === diskHash))
+    )
+      reportDivergentDelivery(cached, props.currentFile);
     // An adopted envelope failed either because the publication does not hold
     // on this disk or because this worker's own window moved around it, and
     // only the first speaks against the publication (samchon/ttsc#1479). The
@@ -977,6 +1005,15 @@ export async function captureTransformGeneration(props: {
       });
     }
     cached.projectSnapshotComplete = stableProjectSnapshot;
+    cached.snapshotDeliveryOnly = snapshotDeliveryOnly;
+    if (cached.snapshotDeliveryOnly && props.deliveryEpoch !== undefined)
+      cached.passDeliveryOnly = true;
+    if (cached.snapshotDeliveryOnly)
+      cached.sourceHashes = captureTransformSourceHashes(
+        cached,
+        props.currentFile,
+        diskHash ?? deliveredHash,
+      );
     // Attach notifications only while they can actually prove membership. A
     // generation that could not open its watchers keeps its recorded snapshot
     // and validates through it, rather than losing the cache entirely.

package/src/core/transform/generation/captureTransformSourceHashes.ts

@@ -8,22 +8,24 @@ import { hostInputStateHash } from "../inputs/hostInputStateHash";
 
 /**
  * Capture native host-state hashes for source paths named by transform outputs,
- * including sources outside the project walk. Reads hash raw bytes; a failed
- * read of an observed directory retains the host-state directory marker, while
- * other unreadable output paths remain absent.
+ * including sources outside the project walk. Snapshot-only delivery instead
+ * preserves the compiler's recorded hash where available. Ordinary reads hash
+ * raw bytes; a failed read of an observed directory retains the host-state
+ * directory marker, while other unreadable output paths remain absent.
  *
  * The current source identity is then overwritten with the caller's selected
  * hash even when no output names it. Capture supplies its post-compile project
  * walk's disk hash when available and otherwise the delivered-text hash; that
  * fallback does not establish that the compiler observed those bytes. If the
- * output pass already read this source, the final assignment does not undo it.
+ * output pass already recorded this source for snapshot-only delivery, the
+ * compiler's hash keeps precedence over the caller fallback.
  *
- * @evidence contracts/common.md#principled-implementation Successful output keys identify source paths relative to the project; native host-state hashes become identity-keyed baselines and the caller's selected disk-or-delivery hash overrides the current identity without granting generation completeness.
+ * @evidence contracts/common.md#principled-implementation Successful output keys identify source paths relative to the project; native host-state hashes become identity-keyed baselines and the caller's selected disk-or-delivery hash overrides the current identity for ordinary delivery, while snapshot-only delivery preserves captured compiler hashes without granting generation completeness.
  * @evidence contracts/common.md#clear-and-simple-design This helper constructs only the source baseline map; resultFilesystem supplies native reads and envelopeDerivation supplies the generation's shared identity context.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Non-directory failed reads supply no fabricated output-source hash, and transformed output text is never hashed as source. The explicitly supplied current-source fallback is distinguished from native disk evidence; the capture owner separately decides completeness and reuse.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish raw host state, directory markers and failed reads from the current source's caller-selected fallback and explain the output-pass read that an override cannot avoid.
  * @evidence contracts/portability.md#os-neutral-implementation Output paths are resolved with Node native semantics and compared through the envelope identity context; no case folding or OS-specific file reader is introduced.
- * @evidence contracts/performance.md#efficient-algorithms Object.keys allocates the full output-key array, then one pass resolves native spellings, reads and hashes each exposed source's bytes and inserts successful host states. Failed reads may stat; identity resolution may observe uncached ancestors and case capabilities. Distinct output spellings may repeat a physical read before sharing one key. Map storage grows with distinct identities and key text; the final current assignment adds no read beyond that pass.
+ * @evidence contracts/performance.md#efficient-algorithms Object.keys allocates the full output-key array, then one pass resolves native spellings and inserts compiler-recorded hashes for snapshot-only delivery, otherwise reading and hashing each exposed source's bytes for host state. Failed reads may stat; identity resolution may observe uncached ancestors and case capabilities. Distinct output spellings may repeat a physical read before sharing one key. Map storage grows with distinct identities and key text; the final current assignment adds no read beyond that pass.
  * @evidence contracts/performance.md#reuse-equivalent-work The caller's selected current hash and the immutable envelope's identity transaction are reused; the output pass does not memoize content reads by physical identity. The fresh map belongs to this capture rather than reusing historical content across changes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Generation capture owns the returned baseline map's lifetime; this helper acquires no retained handle or observer.
  */
@@ -41,10 +43,19 @@ export function captureTransformSourceHashes(
   if (cached.result.type === "success") {
     for (const output of Object.keys(cached.result.typescript)) {
       const file = path.resolve(cached.projectRoot, output);
-      const hash = hostInputStateHash(file, filesystem);
+      const hash =
+        cached.snapshotDeliveryOnly === true &&
+        Object.hasOwn(cached.result.graph?.inputHashes ?? {}, output)
+          ? (cached.result.graph!.inputHashes![output] ?? null)
+          : hostInputStateHash(file, filesystem);
       if (hash !== null) hashes[pathIdentityKey(file, identities)] = hash;
     }
   }
-  hashes[pathIdentityKey(currentFile, identities)] = currentSourceHash;
+  const currentIdentity = pathIdentityKey(currentFile, identities);
+  if (
+    cached.snapshotDeliveryOnly !== true ||
+    hashes[currentIdentity] === undefined
+  )
+    hashes[currentIdentity] = currentSourceHash;
   return hashes;
 }

package/src/core/transform/generation/compilerSnapshotFailureClassifier.ts

@@ -0,0 +1,80 @@
+import path from "node:path";
+import type { ITtscCompilerTransformation } from "ttsc";
+
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure";
+
+/**
+ * Index one native snapshot's recorded inputs for streaming freshness
+ * classification. The diagnostic witness limit must not decide whether a
+ * compilation is coherent, so compatibility is decided before diagnostic
+ * truncation and remains refused after the first incompatible occurrence.
+ *
+ * @evidence contracts/common.md#principled-implementation Only explicit freshness changes to recorded compiler inputs or project discovery qualify; changed configuration selection and conflicting host/compiler reads do not; missing and contradictory producer evidence stays outside this class.
+ * @evidence contracts/common.md#clear-and-simple-design One generation-owned classifier is shared by its proof collectors and final delivery admission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No failure is ignored because its printable witness exceeded the diagnostic limit; unknown kinds and unrecorded plugin inputs remain refusals.
+ * @evidence contracts/common.md#meaningful-documentation Prose explains streaming classification, diagnostic truncation and generation ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve anchors protocol input names without guessing physical identity or case behavior.
+ * @evidence contracts/performance.md#efficient-algorithms Compiler observation and host hash indexes cost recorded path bytes and input counts; each failure uses a kind check and indexed lexical lookup.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every collector for this generation borrows the same classifier and recorded-input index; another generation constructs its own view.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The generation owns its path index and closure until eviction or disposal releases the generation; retained paths follow the reported input population with no separate handle.
+ */
+export function compilerSnapshotFailureClassifier(
+  result: ITtscCompilerTransformation,
+  projectRoot: string,
+): ((failure: TtscGenerationProofFailure) => boolean) | undefined {
+  if (result.type !== "success" || !result.graph?.compilationSnapshot)
+    return undefined;
+  const recorded = new Map(
+    Object.entries(result.graph.inputObservations ?? {}).map(
+      ([file, observation]) => [path.resolve(projectRoot, file), observation],
+    ),
+  );
+  const hostHashes = new Map(
+    Object.entries(result.hostInputHashes ?? {}).map(([file, hash]) => [
+      path.resolve(projectRoot, file),
+      hash,
+    ]),
+  );
+  const freshnessKinds = new Set([
+    "content-changed",
+    "realpath-changed",
+    "graph-content-changed",
+    "graph-realpath-changed",
+    "accessible-entries-changed",
+    "file-exists-changed",
+    "directory-exists-changed",
+    "stat-changed",
+    "read-file-changed",
+    "native-file-changed",
+    "native-directory-changed",
+    "native-entry-changed",
+    "native-optional-file-changed",
+    "input-content-changed",
+    "input-metadata-changed",
+    "directory-membership-changed",
+    "directory-changed-during-walk",
+    "file-changed-during-read",
+    "project-membership-event",
+    "membership-policy-learned",
+    "snapshot-mismatch",
+    "changed-during-validation",
+  ]);
+  return (failure) => {
+    if (!freshnessKinds.has(failure.kind)) return false;
+    if (failure.domain === "project") return true;
+    if (failure.path === undefined) return false;
+    const file = path.resolve(failure.path);
+    const observation = recorded.get(file);
+    if (observation === undefined) return false;
+    // A descriptor/host read must agree with the compiler's captured text.
+    // Merely sharing a path cannot make two different evaluation epochs coherent.
+    if (failure.domain === "host" && hostHashes.has(file)) {
+      const read = observation.readFile;
+      return (
+        read !== undefined &&
+        hostHashes.get(file) === (read.ok ? read.hash : null)
+      );
+    }
+    return true;
+  };
+}

package/src/core/transform/generation/createGenerationProofFailures.ts

@@ -4,15 +4,24 @@ import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures"
  * Create a fresh proof-witness collection for one transform attempt. Its
  * recorder bounds retained entries and their deduplication identities.
  *
- * @evidence contracts/common.md#principled-implementation Empty entries, zero omitted occurrences and an empty seen set establish the recorder's initial aggregate invariants.
+ * @evidence contracts/common.md#principled-implementation Empty entries, zero omitted occurrences and an empty seen set establish the recorder's initial aggregate invariants. The optional generation classifier records complete freshness compatibility before diagnostic truncation.
  * @evidence contracts/common.md#clear-and-simple-design This constructor supplies only fresh aggregate storage; the recorder owns limits and identity composition.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts An attempt receives independent storage rather than sharing mutable witnesses from an earlier compile or manufacturing an initial verdict.
  * @evidence contracts/common.md#meaningful-documentation Native prose identifies per-attempt ownership and the recorder's bounding responsibility before separated acknowledgments.
- * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh storage transfers to the attempt owner and its terminal diagnostic sequence; recordGenerationProofFailure bounds entry and identity counts at eight, while retained witness text follows supplied lengths. This constructor owns no handle or separate historical collection.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh storage transfers to the attempt owner and its terminal diagnostic sequence; recordGenerationProofFailure bounds entry and identity counts at eight, while retained witness text follows supplied lengths. This constructor owns no handle or separate historical collection. The optional borrowed classifier keeps its generation input indexes reachable while either the generation or aggregate retains it; those indexes are not subject to the diagnostic witness bound.
  * @evidenceExclude contracts/performance.md#efficient-algorithms Allocates an empty collection.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work Creates a new collection per attempt by definition.
  * @evidenceExclude contracts/portability.md#os-neutral-implementation Allocates an empty collection and reads no filesystem or path.
  */
-export function createGenerationProofFailures(): TtscGenerationProofFailures {
-  return { entries: [], omitted: 0, seen: new Set() };
+export function createGenerationProofFailures(
+  snapshotFailureClassifier?: TtscGenerationProofFailures["snapshotFailureClassifier"],
+): TtscGenerationProofFailures {
+  return {
+    entries: [],
+    omitted: 0,
+    seen: new Set(),
+    ...(snapshotFailureClassifier === undefined
+      ? {}
+      : { snapshotFailureClassifier, snapshotCompatible: true }),
+  };
 }

package/src/core/transform/generation/mergeGenerationProofFailures.ts

@@ -10,19 +10,19 @@ import { recordGenerationProofFailure } from "./recordGenerationProofFailure";
  * unchanged. Retained witnesses are shared references, so producers must treat
  * their classifications as fixed after recording.
  *
- * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries.
+ * @evidence contracts/common.md#principled-implementation Retained source entries use the target recorder's identity policy, while saturated addition preserves already omitted occurrence counts that cannot be recovered from source entries. A positive omitted-witness summary transfers only under the same generation classifier; refusal remains sticky before diagnostic truncation.
  * @evidence contracts/common.md#clear-and-simple-design This operation coordinates aggregation without duplicating recorder limits or witness identity encoding.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing witnesses remain omitted rather than being silently converted into proof success or guessed unique identities.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared recorder ownership and the reason lost source identities cannot be deduplicated.
  * @evidence contracts/performance.md#efficient-algorithms
  *   Merge visits the source's recorder-bounded retained entries once. Each
  *   delegated insertion encodes the complete witness tuple and queries its
- *   identity, so work and temporary encoded keys retain witness-text cost even
+ *   identity and optionally classifies lexical paths, so work and temporary encoded keys retain witness-text cost even
  *   with at most eight entries. Omission addition is constant work; discarded
  *   evidence is not reconstructed.
  * @evidence contracts/performance.md#reuse-equivalent-work The shared recorder reuses retained target identities to suppress duplicates across evidence families; mutable aggregate merges are not memoized.
- * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count.
- * @evidenceExclude contracts/portability.md#os-neutral-implementation Combines in-memory witness collections; it parses no path.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The target remains subject to the recorder's eight-entry/seen-key bound; merge retains no source history beyond copied witnesses and its saturated omission count. The optional borrowed classifier keeps its generation input indexes reachable while either the generation or aggregate retains it; those indexes are not subject to the diagnostic witness bound.
+ * @evidence contracts/portability.md#os-neutral-implementation Combines in-memory witnesses through the recorder, whose optional generation classifier owns native lexical path resolution.
  */
 export function mergeGenerationProofFailures(
   target: TtscGenerationProofFailures,
@@ -31,6 +31,15 @@ export function mergeGenerationProofFailures(
   for (const failure of source.entries) {
     recordGenerationProofFailure(target, failure);
   }
+  if (
+    target.snapshotFailureClassifier !== undefined &&
+    (source.snapshotCompatible === false ||
+      (source.omitted !== 0 &&
+        (source.snapshotCompatible !== true ||
+          source.snapshotFailureClassifier !==
+            target.snapshotFailureClassifier)))
+  )
+    target.snapshotCompatible = false;
   target.omitted = Math.min(
     Number.MAX_SAFE_INTEGER,
     target.omitted + source.omitted,

package/src/core/transform/generation/recordGenerationProofFailure.ts

@@ -10,19 +10,23 @@ const MAX_GENERATION_PROOF_FAILURES = 8;
  * full, new occurrences increment a saturated omitted count; dropped identities
  * are not retained, so later repetitions of a dropped witness count again.
  *
- * @evidence contracts/common.md#principled-implementation A JSON tuple of domain, kind, path and detail defines witness identity, seen deduplicates retained entries and the entry bound plus saturated omitted counter represent evidence loss explicitly.
+ * @evidence contracts/common.md#principled-implementation A JSON tuple of domain, kind, path and detail defines witness identity, seen deduplicates retained entries and the entry bound plus saturated omitted counter represent evidence loss explicitly. The optional generation classifier records complete freshness compatibility before diagnostic truncation.
  * @evidence contracts/common.md#clear-and-simple-design One recorder owns identity, retained bounds and omission accounting so merge and capture callers share the same aggregate policy.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The eight-entry bound limits diagnostic storage rather than changing the proof verdict; omitted remains visible and no discarded witness is certified irrelevant.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs state retained duplicate handling and the dropped-occurrence limitation, while the internal comment explains why seen shares the storage bound.
- * @evidence contracts/performance.md#efficient-algorithms Identity encoding costs the witness text length and Set membership is direct; insertion touches one entry without rescanning the aggregate.
+ * @evidence contracts/performance.md#efficient-algorithms Identity encoding costs the witness text length and Set membership is direct; insertion touches one entry without rescanning the aggregate. Optional classification adds the generation classifier's lexical path lookup for each occurrence.
  * @evidence contracts/performance.md#reuse-equivalent-work Retained seen keys prevent repeated insertion of the same printable witness; dropped identities intentionally are not shared because doing so would require unbounded storage.
- * @evidence contracts/performance.md#bound-retention-and-release-resources Entries and seen retain at most eight witnesses/keys per attempt, and omitted saturates at MAX_SAFE_INTEGER; text bytes depend on producer witness lengths rather than a claimed byte-size bound.
- * @evidenceExclude contracts/portability.md#os-neutral-implementation Stores the path strings it is given inside a JSON identity key without parsing or comparing them as paths.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Entries and seen retain at most eight witnesses/keys per attempt, and omitted saturates at MAX_SAFE_INTEGER; text bytes depend on producer witness lengths rather than a claimed byte-size bound. The optional borrowed classifier keeps its generation input indexes reachable while either the generation or aggregate retains it; those indexes are not subject to the diagnostic witness bound.
+ * @evidence contracts/portability.md#os-neutral-implementation Witness identity preserves supplied strings; optional freshness classification delegates native lexical path resolution to the generation classifier.
  */
 export function recordGenerationProofFailure(
   failures: TtscGenerationProofFailures,
   failure: TtscGenerationProofFailure,
 ): void {
+  if (failures.snapshotFailureClassifier !== undefined)
+    failures.snapshotCompatible =
+      failures.snapshotCompatible === true &&
+      failures.snapshotFailureClassifier(failure);
   const key = JSON.stringify([
     failure.domain,
     failure.kind,

package/src/core/transform/generation/selectTransformAttemptDisposition.ts

@@ -7,13 +7,15 @@ import { onlyLearnedCompileFacts } from "./onlyLearnedCompileFacts";
  * Select how one completed capture spends the retry owner's budgets. Supplied
  * facts describe the capture; this policy performs no capture or native proof.
  *
- * Coherent results return first. A local, lossless host-observation refusal can
- * transfer an incomplete local success. TtscGenerationProof owns any sharing of
- * its first module deliveries inside an explicit nonwatching pass; this policy
- * grants no independent native or persistent proof. Rejected attempts spend
- * movement only when they neither refute a publication nor solely learn facts.
- * Two movements or four captures stop retrying, retaining a current diagnostic
- * rather than a terminal instability verdict when its config is not refuted.
+ * Coherent results, including admitted current compiler snapshots, return
+ * first. Snapshot delivery does not spend disk-stabilization retries or grant
+ * future reuse. A local, lossless host-observation refusal can transfer an
+ * incomplete local success. TtscGenerationProof owns any sharing of its first
+ * module deliveries inside an explicit nonwatching pass; this policy grants no
+ * independent native or persistent proof. Rejected attempts spend movement only
+ * when they neither refute a publication nor solely learn facts. Two movements
+ * or four captures stop retrying, retaining a current diagnostic rather than a
+ * terminal instability verdict when its config is not refuted.
  *
  * The caller owns learned dependency/case carry, terminal validation, capture
  * disposal and result transfer. Selecting terminal does not certify a baseline
@@ -56,6 +58,9 @@ export function selectTransformAttemptDisposition(props: {
   /** Explicit config coherence; undefined retains the existing admission rule. */
   configStateComplete?: boolean;
 
+  /** Current compiler snapshot authority, independent of disk/cache freshness. */
+  snapshotDeliveryOnly?: boolean;
+
   /** Reusable project success proof, required explicitly for success acceptance. */
   projectSnapshotComplete?: boolean;
 
@@ -101,6 +106,8 @@ export function selectTransformAttemptDisposition(props: {
       moved: number;
       rejected: string | undefined;
     } {
+  if (props.resultType === "success" && props.snapshotDeliveryOnly === true)
+    return { kind: "accepted", freshDeliveryOnly: false };
   const freshDeliveryOnly =
     props.resultType === "failure" &&
     (props.observationsComplete === false ||

package/src/core/transform/generation/transformProject.ts

@@ -181,6 +181,7 @@ export async function transformProject(props: {
     const disposition = selectTransformAttemptDisposition({
       resultType: cached.result.type,
       configStateComplete: cached.configStateComplete,
+      snapshotDeliveryOnly: cached.snapshotDeliveryOnly,
       projectSnapshotComplete: cached.projectSnapshotComplete,
       projectHeldStill: cached.projectHeldStill,
       observationsComplete:

package/src/core/transform/validation/TtscGenerationProof.ts

@@ -24,10 +24,13 @@ import type { TtscTransformHooks } from "../watch/TtscTransformHooks";
  * persistent/repeated deliveries require new current observations. Incomplete
  * observations can share a coherent local result only inside an explicitly
  * nonwatching pass with actual host-cache withdrawal, never a record or pool.
+ * Captured native snapshots separately permit first deliveries in their
+ * original pass, including watching, without claiming disk freshness or future
+ * reuse.
  *
  * @evidence contracts/common.md#principled-implementation Explicit pass identity, source baseline and first-delivery membership delimit sharing; synchronous transactions independently qualify current native inputs and incomplete local outputs retain stricter lifecycle admission.
  * @evidence contracts/common.md#clear-and-simple-design One core owner supplies the same preparation, pass and fresh-only policies to every adapter instead of separate host-specific caches.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observation never becomes complete snapshot authority; watching, persistent, repeated and unknown boundaries cannot borrow an incomplete pass result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observation never becomes complete snapshot authority; watching cannot borrow an observer-unavailable pass result, and persistent, repeated and unknown boundaries cannot borrow either kind of pass-only result.
  * @evidence contracts/common.md#meaningful-documentation Native context names the four lifetimes and warns against the specific performance and stale-cache regressions they prevent.
  * @evidenceExclude contracts/portability.md#os-neutral-implementation Members delegate native observations to the generation's filesystem and the native environment owner.
  * @evidenceExclude contracts/performance.md#efficient-algorithms Members own baseline lookup, batch qualification and admission.

package/src/core/transform/validation/captureExternalInputSnapshot.ts

@@ -126,7 +126,9 @@ export function captureExternalInputSnapshot(
   > = {};
   const realpaths: Record<string, string | null> = {};
   const signatures: Record<string, string> = {};
-  const failures = createGenerationProofFailures();
+  const failures = createGenerationProofFailures(
+    cached.snapshotFailureClassifier,
+  );
   const dependencies: string[] = [];
   const reported = new Set<string>();
   if (cached.result.type !== "exception") {

package/src/core/transform/validation/captureUniversalHostInputValidation.ts

@@ -57,7 +57,9 @@ export function captureUniversalHostInputValidation(
 } {
   const filesystem = resultFilesystem(cached.result);
   const state = envelopeDerivation(cached);
-  const failures = createGenerationProofFailures();
+  const failures = createGenerationProofFailures(
+    cached.snapshotFailureClassifier,
+  );
   const validation: TtscHostInputValidation = {
     entries: new Map(),
     covered: new Set(),

package/src/core/transform/validation/compilerGraphInputProofFailures.ts

@@ -34,7 +34,9 @@ import { isTransformScratchInput } from "../tsconfig/isTransformScratchInput";
 export function compilerGraphInputProofFailures(
   cached: TtscCachedProjectTransform,
 ): TtscGenerationProofFailures {
-  const failures = createGenerationProofFailures();
+  const failures = createGenerationProofFailures(
+    cached.snapshotFailureClassifier,
+  );
   if (
     cached.result.type === "exception" ||
     cached.result.graph === undefined ||