@ttsc/unplugin 0.35.0 → 0.36.1

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

@@ -6,22 +6,24 @@ import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
 
 /**
  * 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.
  */
@@ -38,12 +40,18 @@ currentSourceHash) {
     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/lib/core/transform/generation/captureTransformSourceHashes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"captureTransformSourceHashes.mjs","sources":["../../../../src/core/transform/generation/captureTransformSourceHashes.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,4BAA4B;AAC1C;AACA,MAAkC;AAClC;AACA,WAAmB;AACnB;AACA,iBAAyB,EAAA;IAEzB,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;IAClD,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,eAAe;IAC7D,MAAM,MAAM,GAA2B,EAAE;IACzC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACpC,QAAA,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;AAC1D,YAAA,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC;YACrD,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC;YACjD,IAAI,IAAI,KAAK,IAAI;gBAAE,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI;QACrE;IACF;IACA,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,GAAG,iBAAiB;AACpE,IAAA,OAAO,MAAM;AACf;;;;"}
+{"version":3,"file":"captureTransformSourceHashes.mjs","sources":["../../../../src/core/transform/generation/captureTransformSourceHashes.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;AAsBG;SACa,4BAA4B;AAC1C;AACA,MAAkC;AAClC;AACA,WAAmB;AACnB;AACA,iBAAyB,EAAA;IAEzB,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;IAClD,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,eAAe;IAC7D,MAAM,MAAM,GAA2B,EAAE;IACzC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACpC,QAAA,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;AAC1D,YAAA,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC;AACrD,YAAA,MAAM,IAAI,GACR,MAAM,CAAC,oBAAoB,KAAK,IAAI;AACpC,gBAAA,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,IAAI,EAAE,EAAE,MAAM;AAC1D,mBAAG,MAAM,CAAC,MAAM,CAAC,KAAM,CAAC,WAAY,CAAC,MAAM,CAAC,IAAI,IAAI;AACpD,kBAAE,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC;YAC1C,IAAI,IAAI,KAAK,IAAI;gBAAE,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI;QACrE;IACF;IACA,MAAM,eAAe,GAAG,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC;AAChE,IAAA,IACE,MAAM,CAAC,oBAAoB,KAAK,IAAI;AACpC,QAAA,MAAM,CAAC,eAAe,CAAC,KAAK,SAAS;AAErC,QAAA,MAAM,CAAC,eAAe,CAAC,GAAG,iBAAiB;AAC7C,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,18 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.cjs";
+/**
+ * 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 declare function compilerSnapshotFailureClassifier(result: ITtscCompilerTransformation, projectRoot: string): ((failure: TtscGenerationProofFailure) => boolean) | undefined;

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

@@ -0,0 +1,18 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.mjs";
+/**
+ * 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 declare function compilerSnapshotFailureClassifier(result: ITtscCompilerTransformation, projectRoot: string): ((failure: TtscGenerationProofFailure) => boolean) | undefined;

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

@@ -0,0 +1,18 @@
+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 declare function compilerSnapshotFailureClassifier(result: ITtscCompilerTransformation, projectRoot: string): ((failure: TtscGenerationProofFailure) => boolean) | undefined;

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

@@ -0,0 +1,75 @@
+'use strict';
+
+var path = require('node:path');
+
+/**
+ * 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.
+ */
+function compilerSnapshotFailureClassifier(result, projectRoot) {
+    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;
+    };
+}
+
+exports.compilerSnapshotFailureClassifier = compilerSnapshotFailureClassifier;
+//# sourceMappingURL=compilerSnapshotFailureClassifier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compilerSnapshotFailureClassifier.js","sources":["../../../../src/core/transform/generation/compilerSnapshotFailureClassifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;AAcG;AACG,SAAU,iCAAiC,CAC/C,MAAmC,EACnC,WAAmB,EAAA;IAEnB,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB;AACjE,QAAA,OAAO,SAAS;AAClB,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CACtD,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CACxE,CACF;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CACxB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK;AACjE,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC;QAC/B,IAAI;AACL,KAAA,CAAC,CACH;AACD,IAAA,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;QAC7B,iBAAiB;QACjB,kBAAkB;QAClB,uBAAuB;QACvB,wBAAwB;QACxB,4BAA4B;QAC5B,qBAAqB;QACrB,0BAA0B;QAC1B,cAAc;QACd,mBAAmB;QACnB,qBAAqB;QACrB,0BAA0B;QAC1B,sBAAsB;QACtB,8BAA8B;QAC9B,uBAAuB;QACvB,wBAAwB;QACxB,8BAA8B;QAC9B,+BAA+B;QAC/B,0BAA0B;QAC1B,0BAA0B;QAC1B,2BAA2B;QAC3B,mBAAmB;QACnB,2BAA2B;AAC5B,KAAA,CAAC;IACF,OAAO,CAAC,OAAO,KAAI;QACjB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO,KAAK;AACnD,QAAA,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS;AAAE,YAAA,OAAO,IAAI;AAC7C,QAAA,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;QAC5C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;QACvC,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;QACtC,IAAI,WAAW,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;;;AAG3C,QAAA,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACrD,YAAA,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ;YACjC,QACE,IAAI,KAAK,SAAS;gBAClB,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEzD;AACA,QAAA,OAAO,IAAI;AACb,IAAA,CAAC;AACH;;;;"}

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

@@ -0,0 +1,73 @@
+import path from 'node:path';
+
+/**
+ * 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.
+ */
+function compilerSnapshotFailureClassifier(result, projectRoot) {
+    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;
+    };
+}
+
+export { compilerSnapshotFailureClassifier };
+//# sourceMappingURL=compilerSnapshotFailureClassifier.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compilerSnapshotFailureClassifier.mjs","sources":["../../../../src/core/transform/generation/compilerSnapshotFailureClassifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;AAcG;AACG,SAAU,iCAAiC,CAC/C,MAAmC,EACnC,WAAmB,EAAA;IAEnB,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB;AACjE,QAAA,OAAO,SAAS;AAClB,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CACtD,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,CACxE,CACF;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CACxB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK;AACjE,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC;QAC/B,IAAI;AACL,KAAA,CAAC,CACH;AACD,IAAA,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;QAC7B,iBAAiB;QACjB,kBAAkB;QAClB,uBAAuB;QACvB,wBAAwB;QACxB,4BAA4B;QAC5B,qBAAqB;QACrB,0BAA0B;QAC1B,cAAc;QACd,mBAAmB;QACnB,qBAAqB;QACrB,0BAA0B;QAC1B,sBAAsB;QACtB,8BAA8B;QAC9B,uBAAuB;QACvB,wBAAwB;QACxB,8BAA8B;QAC9B,+BAA+B;QAC/B,0BAA0B;QAC1B,0BAA0B;QAC1B,2BAA2B;QAC3B,mBAAmB;QACnB,2BAA2B;AAC5B,KAAA,CAAC;IACF,OAAO,CAAC,OAAO,KAAI;QACjB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO,KAAK;AACnD,QAAA,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS;AAAE,YAAA,OAAO,IAAI;AAC7C,QAAA,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;QAC5C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;QACvC,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;QACtC,IAAI,WAAW,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;;;AAG3C,QAAA,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACrD,YAAA,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ;YACjC,QACE,IAAI,KAAK,SAAS;gBAClB,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEzD;AACA,QAAA,OAAO,IAAI;AACb,IAAA,CAAC;AACH;;;;"}

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

@@ -3,13 +3,13 @@ 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 declare function createGenerationProofFailures(): TtscGenerationProofFailures;
+export declare function createGenerationProofFailures(snapshotFailureClassifier?: TtscGenerationProofFailures["snapshotFailureClassifier"]): TtscGenerationProofFailures;

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

@@ -3,13 +3,13 @@ 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 declare function createGenerationProofFailures(): TtscGenerationProofFailures;
+export declare function createGenerationProofFailures(snapshotFailureClassifier?: TtscGenerationProofFailures["snapshotFailureClassifier"]): TtscGenerationProofFailures;

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

@@ -3,13 +3,13 @@ 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 declare function createGenerationProofFailures(): TtscGenerationProofFailures;
+export declare function createGenerationProofFailures(snapshotFailureClassifier?: TtscGenerationProofFailures["snapshotFailureClassifier"]): TtscGenerationProofFailures;

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

@@ -4,17 +4,24 @@
  * 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.
  */
-function createGenerationProofFailures() {
-    return { entries: [], omitted: 0, seen: new Set() };
+function createGenerationProofFailures(snapshotFailureClassifier) {
+    return {
+        entries: [],
+        omitted: 0,
+        seen: new Set(),
+        ...(snapshotFailureClassifier === undefined
+            ? {}
+            : { snapshotFailureClassifier, snapshotCompatible: true }),
+    };
 }
 
 exports.createGenerationProofFailures = createGenerationProofFailures;

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

@@ -1 +1 @@
-{"version":3,"file":"createGenerationProofFailures.js","sources":["../../../../src/core/transform/generation/createGenerationProofFailures.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;AAYG;SACa,6BAA6B,GAAA;AAC3C,IAAA,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,EAAE;AACrD;;;;"}
+{"version":3,"file":"createGenerationProofFailures.js","sources":["../../../../src/core/transform/generation/createGenerationProofFailures.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;AAYG;AACG,SAAU,6BAA6B,CAC3C,yBAAoF,EAAA;IAEpF,OAAO;AACL,QAAA,OAAO,EAAE,EAAE;AACX,QAAA,OAAO,EAAE,CAAC;QACV,IAAI,EAAE,IAAI,GAAG,EAAE;QACf,IAAI,yBAAyB,KAAK;AAChC,cAAE;cACA,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;KAC7D;AACH;;;;"}

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

@@ -2,17 +2,24 @@
  * 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.
  */
-function createGenerationProofFailures() {
-    return { entries: [], omitted: 0, seen: new Set() };
+function createGenerationProofFailures(snapshotFailureClassifier) {
+    return {
+        entries: [],
+        omitted: 0,
+        seen: new Set(),
+        ...(snapshotFailureClassifier === undefined
+            ? {}
+            : { snapshotFailureClassifier, snapshotCompatible: true }),
+    };
 }
 
 export { createGenerationProofFailures };

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

@@ -1 +1 @@
-{"version":3,"file":"createGenerationProofFailures.mjs","sources":["../../../../src/core/transform/generation/createGenerationProofFailures.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;AAYG;SACa,6BAA6B,GAAA;AAC3C,IAAA,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,EAAE;AACrD;;;;"}
+{"version":3,"file":"createGenerationProofFailures.mjs","sources":["../../../../src/core/transform/generation/createGenerationProofFailures.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;AAYG;AACG,SAAU,6BAA6B,CAC3C,yBAAoF,EAAA;IAEpF,OAAO;AACL,QAAA,OAAO,EAAE,EAAE;AACX,QAAA,OAAO,EAAE,CAAC;QACV,IAAI,EAAE,IAAI,GAAG,EAAE;QACf,IAAI,yBAAyB,KAAK;AAChC,cAAE;cACA,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;KAC7D;AACH;;;;"}

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

@@ -8,18 +8,18 @@ import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.
  * 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 declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

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

@@ -8,18 +8,18 @@ import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.
  * 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 declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

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

@@ -8,18 +8,18 @@ import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures"
  * 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 declare function mergeGenerationProofFailures(target: TtscGenerationProofFailures, source: TtscGenerationProofFailures): void;

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

@@ -11,24 +11,31 @@ var recordGenerationProofFailure = require('./recordGenerationProofFailure.js');
  * 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.
  */
 function mergeGenerationProofFailures(target, source) {
     for (const failure of source.entries) {
         recordGenerationProofFailure.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/lib/core/transform/generation/mergeGenerationProofFailures.js.map

@@ -1 +1 @@
-{"version":3,"file":"mergeGenerationProofFailures.js","sources":["../../../../src/core/transform/generation/mergeGenerationProofFailures.ts"],"sourcesContent":[null],"names":["recordGenerationProofFailure"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,4BAA4B,CAC1C,MAAmC,EACnC,MAAmC,EAAA;AAEnC,IAAA,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE;AACpC,QAAAA,yDAA4B,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/C;AACA,IAAA,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CACvB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAChC;AACH;;;;"}
+{"version":3,"file":"mergeGenerationProofFailures.js","sources":["../../../../src/core/transform/generation/mergeGenerationProofFailures.ts"],"sourcesContent":[null],"names":["recordGenerationProofFailure"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,4BAA4B,CAC1C,MAAmC,EACnC,MAAmC,EAAA;AAEnC,IAAA,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE;AACpC,QAAAA,yDAA4B,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/C;AACA,IAAA,IACE,MAAM,CAAC,yBAAyB,KAAK,SAAS;AAC9C,SAAC,MAAM,CAAC,kBAAkB,KAAK,KAAK;AAClC,aAAC,MAAM,CAAC,OAAO,KAAK,CAAC;AACnB,iBAAC,MAAM,CAAC,kBAAkB,KAAK,IAAI;AACjC,oBAAA,MAAM,CAAC,yBAAyB;AAC9B,wBAAA,MAAM,CAAC,yBAAyB,CAAC,CAAC,CAAC;AAE3C,QAAA,MAAM,CAAC,kBAAkB,GAAG,KAAK;AACnC,IAAA,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CACvB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAChC;AACH;;;;"}

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

@@ -9,24 +9,31 @@ import { recordGenerationProofFailure } from './recordGenerationProofFailure.mjs
  * 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.
  */
 function mergeGenerationProofFailures(target, source) {
     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);
 }