@ttsc/unplugin 0.35.0 → 0.36.1

package/lib/core/transform/cache/TtscCachedProjectTransform.d.cts

@@ -1,6 +1,7 @@
 import type { ITtscCompilerTransformation } from "ttsc";
 import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
 import type { TtscCompilerMembershipHint } from "../generation/TtscCompilerMembershipHint.cjs";
+import type { TtscGenerationProofFailure } from "../generation/TtscGenerationProofFailure.cjs";
 import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot.cjs";
 import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.cjs";
 import type { TtscCompilerArgumentsWitness } from "../tsconfig/TtscCompilerArgumentsWitness.cjs";
@@ -17,6 +18,8 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  * generation before later first deliveries may share that proof. Deliveries
  * reaching source-baseline comparison still cost a text hash and may require
  * disk comparison when they diverge; unrelated modules can return before it.
+ * Captured native snapshots may instead retain original-pass delivery only,
+ * without claiming the edited disk still matches or granting future reuse.
  * Persistent graph-bearing requests may use derived-input validation only with
  * qualified membership and universal authority; unavailable narrow proof uses
  * the complete recorded snapshot.
@@ -42,6 +45,25 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  *   retained state at runtime.
  */
 export interface TtscCachedProjectTransform {
+    /**
+     * Coherent captured output whose disk freshness was lost; never shared or
+     * persisted.
+     */
+    snapshotDeliveryOnly?: 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;
     /** Native settings learned under this capture's validated config-policy basis. */
     compilerMembership?: TtscCompilerMembershipHint;
     /** Actual captured invocation, retained for persisted host-cache proofs. */

package/lib/core/transform/cache/TtscCachedProjectTransform.d.mts

@@ -1,6 +1,7 @@
 import type { ITtscCompilerTransformation } from "ttsc";
 import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
 import type { TtscCompilerMembershipHint } from "../generation/TtscCompilerMembershipHint.mjs";
+import type { TtscGenerationProofFailure } from "../generation/TtscGenerationProofFailure.mjs";
 import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot.mjs";
 import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker.mjs";
 import type { TtscCompilerArgumentsWitness } from "../tsconfig/TtscCompilerArgumentsWitness.mjs";
@@ -17,6 +18,8 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  * generation before later first deliveries may share that proof. Deliveries
  * reaching source-baseline comparison still cost a text hash and may require
  * disk comparison when they diverge; unrelated modules can return before it.
+ * Captured native snapshots may instead retain original-pass delivery only,
+ * without claiming the edited disk still matches or granting future reuse.
  * Persistent graph-bearing requests may use derived-input validation only with
  * qualified membership and universal authority; unavailable narrow proof uses
  * the complete recorded snapshot.
@@ -42,6 +45,25 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  *   retained state at runtime.
  */
 export interface TtscCachedProjectTransform {
+    /**
+     * Coherent captured output whose disk freshness was lost; never shared or
+     * persisted.
+     */
+    snapshotDeliveryOnly?: 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;
     /** Native settings learned under this capture's validated config-policy basis. */
     compilerMembership?: TtscCompilerMembershipHint;
     /** Actual captured invocation, retained for persisted host-cache proofs. */

package/lib/core/transform/cache/TtscCachedProjectTransform.d.ts

@@ -1,6 +1,7 @@
 import type { ITtscCompilerTransformation } from "ttsc";
 import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
 import type { TtscCompilerMembershipHint } from "../generation/TtscCompilerMembershipHint";
+import type { TtscGenerationProofFailure } from "../generation/TtscGenerationProofFailure";
 import type { TtscProjectDirectorySnapshot } from "../project/TtscProjectDirectorySnapshot";
 import type { TtscProjectMutationTracker } from "../tracker/TtscProjectMutationTracker";
 import type { TtscCompilerArgumentsWitness } from "../tsconfig/TtscCompilerArgumentsWitness";
@@ -17,6 +18,8 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  * generation before later first deliveries may share that proof. Deliveries
  * reaching source-baseline comparison still cost a text hash and may require
  * disk comparison when they diverge; unrelated modules can return before it.
+ * Captured native snapshots may instead retain original-pass delivery only,
+ * without claiming the edited disk still matches or granting future reuse.
  * Persistent graph-bearing requests may use derived-input validation only with
  * qualified membership and universal authority; unavailable narrow proof uses
  * the complete recorded snapshot.
@@ -42,6 +45,25 @@ import type { TtscHostInputValidation } from "../validation/TtscHostInputValidat
  *   retained state at runtime.
  */
 export interface TtscCachedProjectTransform {
+    /**
+     * Coherent captured output whose disk freshness was lost; never shared or
+     * persisted.
+     */
+    snapshotDeliveryOnly?: 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;
     /** Native settings learned under this capture's validated config-policy basis. */
     compilerMembership?: TtscCompilerMembershipHint;
     /** Actual captured invocation, retained for persisted host-cache proofs. */

package/lib/core/transform/deliverCachedTransform.js

@@ -37,6 +37,8 @@ function deliverCachedTransform(props) {
     const { cache, cached, generation, key, epoch, file, source, hooks, selection, } = props;
     try {
         TtscGenerationProof.TtscGenerationProof.admitFreshOnly(cached, cache, key, generation, epoch, hooks);
+        if (cached.snapshotDeliveryOnly === true)
+            hooks?.markVolatile?.();
         reportSuccessDiagnostics.reportSuccessDiagnostics(cached, epoch);
         let output;
         try {
@@ -63,7 +65,8 @@ function deliverCachedTransform(props) {
         return createTransformResult.createTransformResult(file, source, output);
     }
     catch (error) {
-        if (cached.freshDeliveryOnly === true)
+        if (cached.freshDeliveryOnly === true ||
+            cached.snapshotDeliveryOnly === true)
             evictGeneration.evictGeneration(cache, key, generation);
         throw error;
     }

package/lib/core/transform/deliverCachedTransform.js.map

@@ -1 +1 @@
-{"version":3,"file":"deliverCachedTransform.js","sources":["../../../src/core/transform/deliverCachedTransform.ts"],"sourcesContent":[null],"names":["TtscGenerationProof","reportSuccessDiagnostics","selectOrEvict","TtscMissingProgramOutputError","notifyFailedGenerationInputs","reportMissingProgramOutput","notifyWatchInputs","markCachedSourceServed","notifyVolatileDelivery","createTransformResult","evictGeneration"],"mappings":";;;;;;;;;;;;;;AAgBA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CAAC,KAUtC,EAAA;IACC,MAAM,EACJ,KAAK,EACL,MAAM,EACN,UAAU,EACV,GAAG,EACH,KAAK,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,GACV,GAAG,KAAK;AACT,IAAA,IAAI;AACF,QAAAA,uCAAmB,CAAC,cAAc,CAChC,MAAM,EACN,KAAK,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,CACN;AACD,QAAAC,iDAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AACvC,QAAA,IAAI,MAAM;AACV,QAAA,IAAI;YACF,MAAM,GAAGC,2BAAa,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE;gBACpD,IAAI;gBACJ,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AAC1B,aAAA,CAAC;QACJ;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,EAAE,KAAK,YAAYC,2DAA6B,CAAC,EAAE;gBACrDC,yDAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AAC5D,gBAAA,MAAM,KAAK;YACb;AACA,YAAAC,qDAA0B,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC;YAChDC,mCAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,YAAAC,6CAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,YAAA,OAAO,SAAS;QAClB;QACAD,mCAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,QAAAC,6CAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,QAAAC,6CAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;QAC3C,OAAOC,2CAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IACpD;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI;AACnC,YAAAC,+BAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;AACzC,QAAA,MAAM,KAAK;IACb;AACF;;;;"}
+{"version":3,"file":"deliverCachedTransform.js","sources":["../../../src/core/transform/deliverCachedTransform.ts"],"sourcesContent":[null],"names":["TtscGenerationProof","reportSuccessDiagnostics","selectOrEvict","TtscMissingProgramOutputError","notifyFailedGenerationInputs","reportMissingProgramOutput","notifyWatchInputs","markCachedSourceServed","notifyVolatileDelivery","createTransformResult","evictGeneration"],"mappings":";;;;;;;;;;;;;;AAgBA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CAAC,KAUtC,EAAA;IACC,MAAM,EACJ,KAAK,EACL,MAAM,EACN,UAAU,EACV,GAAG,EACH,KAAK,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,GACV,GAAG,KAAK;AACT,IAAA,IAAI;AACF,QAAAA,uCAAmB,CAAC,cAAc,CAChC,MAAM,EACN,KAAK,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,CACN;AACD,QAAA,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI;AAAE,YAAA,KAAK,EAAE,YAAY,IAAI;AACjE,QAAAC,iDAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AACvC,QAAA,IAAI,MAAM;AACV,QAAA,IAAI;YACF,MAAM,GAAGC,2BAAa,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE;gBACpD,IAAI;gBACJ,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AAC1B,aAAA,CAAC;QACJ;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,EAAE,KAAK,YAAYC,2DAA6B,CAAC,EAAE;gBACrDC,yDAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AAC5D,gBAAA,MAAM,KAAK;YACb;AACA,YAAAC,qDAA0B,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC;YAChDC,mCAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,YAAAC,6CAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,YAAA,OAAO,SAAS;QAClB;QACAD,mCAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,QAAAC,6CAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,QAAAC,6CAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;QAC3C,OAAOC,2CAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IACpD;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IACE,MAAM,CAAC,iBAAiB,KAAK,IAAI;YACjC,MAAM,CAAC,oBAAoB,KAAK,IAAI;AAEpC,YAAAC,+BAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;AACzC,QAAA,MAAM,KAAK;IACb;AACF;;;;"}

package/lib/core/transform/deliverCachedTransform.mjs

@@ -35,6 +35,8 @@ function deliverCachedTransform(props) {
     const { cache, cached, generation, key, epoch, file, source, hooks, selection, } = props;
     try {
         TtscGenerationProof.admitFreshOnly(cached, cache, key, generation, epoch, hooks);
+        if (cached.snapshotDeliveryOnly === true)
+            hooks?.markVolatile?.();
         reportSuccessDiagnostics(cached, epoch);
         let output;
         try {
@@ -61,7 +63,8 @@ function deliverCachedTransform(props) {
         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/lib/core/transform/deliverCachedTransform.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"deliverCachedTransform.mjs","sources":["../../../src/core/transform/deliverCachedTransform.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAgBA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CAAC,KAUtC,EAAA;IACC,MAAM,EACJ,KAAK,EACL,MAAM,EACN,UAAU,EACV,GAAG,EACH,KAAK,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,GACV,GAAG,KAAK;AACT,IAAA,IAAI;AACF,QAAA,mBAAmB,CAAC,cAAc,CAChC,MAAM,EACN,KAAK,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,CACN;AACD,QAAA,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AACvC,QAAA,IAAI,MAAM;AACV,QAAA,IAAI;YACF,MAAM,GAAG,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE;gBACpD,IAAI;gBACJ,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AAC1B,aAAA,CAAC;QACJ;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,EAAE,KAAK,YAAY,6BAA6B,CAAC,EAAE;gBACrD,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AAC5D,gBAAA,MAAM,KAAK;YACb;AACA,YAAA,0BAA0B,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC;YAChD,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,YAAA,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,YAAA,OAAO,SAAS;QAClB;QACA,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,QAAA,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,QAAA,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;QAC3C,OAAO,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IACpD;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI;AACnC,YAAA,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;AACzC,QAAA,MAAM,KAAK;IACb;AACF;;;;"}
+{"version":3,"file":"deliverCachedTransform.mjs","sources":["../../../src/core/transform/deliverCachedTransform.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAgBA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,sBAAsB,CAAC,KAUtC,EAAA;IACC,MAAM,EACJ,KAAK,EACL,MAAM,EACN,UAAU,EACV,GAAG,EACH,KAAK,EACL,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,GACV,GAAG,KAAK;AACT,IAAA,IAAI;AACF,QAAA,mBAAmB,CAAC,cAAc,CAChC,MAAM,EACN,KAAK,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,CACN;AACD,QAAA,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI;AAAE,YAAA,KAAK,EAAE,YAAY,IAAI;AACjE,QAAA,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC;AACvC,QAAA,IAAI,MAAM;AACV,QAAA,IAAI;YACF,MAAM,GAAG,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE;gBACpD,IAAI;gBACJ,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AAC1B,aAAA,CAAC;QACJ;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,EAAE,KAAK,YAAY,6BAA6B,CAAC,EAAE;gBACrD,4BAA4B,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AAC5D,gBAAA,MAAM,KAAK;YACb;AACA,YAAA,0BAA0B,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC;YAChD,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,YAAA,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,YAAA,OAAO,SAAS;QAClB;QACA,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC;AACjD,QAAA,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,QAAA,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;QAC3C,OAAO,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;IACpD;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IACE,MAAM,CAAC,iBAAiB,KAAK,IAAI;YACjC,MAAM,CAAC,oBAAoB,KAAK,IAAI;AAEpC,YAAA,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,CAAC;AACzC,QAAA,MAAM,KAAK;IACb;AACF;;;;"}

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.d.cts

@@ -0,0 +1,16 @@
+import type { TtscTransformFilesystemOperations } from "./TtscTransformFilesystemOperations.cjs";
+/**
+ * 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 declare function matchesNativeCompilerSnapshotFilesystem(filesystem: TtscTransformFilesystemOperations): boolean;

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.d.mts

@@ -0,0 +1,16 @@
+import type { TtscTransformFilesystemOperations } from "./TtscTransformFilesystemOperations.mjs";
+/**
+ * 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 declare function matchesNativeCompilerSnapshotFilesystem(filesystem: TtscTransformFilesystemOperations): boolean;

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.d.ts

@@ -0,0 +1,16 @@
+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 declare function matchesNativeCompilerSnapshotFilesystem(filesystem: TtscTransformFilesystemOperations): boolean;

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('./DEFAULT_FILESYSTEM_OPERATIONS.js');
+
+/**
+ * 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.
+ */
+function matchesNativeCompilerSnapshotFilesystem(filesystem) {
+    if (filesystem.caseSensitive !== undefined ||
+        (filesystem.platform !== undefined &&
+            filesystem.platform !== process.platform))
+        return false;
+    return Object.entries(DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS).every(([name, operation]) => filesystem[name] === operation);
+}
+
+exports.matchesNativeCompilerSnapshotFilesystem = matchesNativeCompilerSnapshotFilesystem;
+//# sourceMappingURL=matchesNativeCompilerSnapshotFilesystem.js.map

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchesNativeCompilerSnapshotFilesystem.js","sources":["../../../../src/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;AAGA;;;;;;;;;;;;;AAaG;AACG,SAAU,uCAAuC,CACrD,UAA6C,EAAA;AAE7C,IAAA,IACE,UAAU,CAAC,aAAa,KAAK,SAAS;AACtC,SAAC,UAAU,CAAC,QAAQ,KAAK,SAAS;AAChC,YAAA,UAAU,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC;AAE3C,QAAA,OAAO,KAAK;IACd,OAAO,MAAM,CAAC,OAAO,CAACA,2DAA6B,CAAC,CAAC,KAAK,CACxD,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,KAChB,UAAU,CAAC,IAA+C,CAAC,KAAK,SAAS,CAC5E;AACH;;;;"}

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.mjs

@@ -0,0 +1,26 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from './DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+
+/**
+ * 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.
+ */
+function matchesNativeCompilerSnapshotFilesystem(filesystem) {
+    if (filesystem.caseSensitive !== undefined ||
+        (filesystem.platform !== undefined &&
+            filesystem.platform !== process.platform))
+        return false;
+    return Object.entries(DEFAULT_FILESYSTEM_OPERATIONS).every(([name, operation]) => filesystem[name] === operation);
+}
+
+export { matchesNativeCompilerSnapshotFilesystem };
+//# sourceMappingURL=matchesNativeCompilerSnapshotFilesystem.mjs.map

package/lib/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchesNativeCompilerSnapshotFilesystem.mjs","sources":["../../../../src/core/transform/filesystem/matchesNativeCompilerSnapshotFilesystem.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;AAaG;AACG,SAAU,uCAAuC,CACrD,UAA6C,EAAA;AAE7C,IAAA,IACE,UAAU,CAAC,aAAa,KAAK,SAAS;AACtC,SAAC,UAAU,CAAC,QAAQ,KAAK,SAAS;AAChC,YAAA,UAAU,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC;AAE3C,QAAA,OAAO,KAAK;IACd,OAAO,MAAM,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC,KAAK,CACxD,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,KAChB,UAAU,CAAC,IAA+C,CAAC,KAAK,SAAS,CAC5E;AACH;;;;"}

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

@@ -22,6 +22,25 @@ import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.cj
 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/lib/core/transform/generation/TtscGenerationProofFailures.d.mts

@@ -22,6 +22,25 @@ import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.mj
 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/lib/core/transform/generation/TtscGenerationProofFailures.d.ts

@@ -22,6 +22,25 @@ import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure";
 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/lib/core/transform/generation/canDeliverCompilerSnapshot.d.cts

@@ -0,0 +1,25 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/**
+ * 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 declare function canDeliverCompilerSnapshot(props: {
+    result: ITtscCompilerTransformation;
+    projectRoot: string;
+    failures: TtscGenerationProofFailures;
+    adopted: boolean;
+}): boolean;

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

@@ -0,0 +1,25 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.mjs";
+/**
+ * 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 declare function canDeliverCompilerSnapshot(props: {
+    result: ITtscCompilerTransformation;
+    projectRoot: string;
+    failures: TtscGenerationProofFailures;
+    adopted: boolean;
+}): boolean;

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

@@ -0,0 +1,25 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+/**
+ * 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 declare function canDeliverCompilerSnapshot(props: {
+    result: ITtscCompilerTransformation;
+    projectRoot: string;
+    failures: TtscGenerationProofFailures;
+    adopted: boolean;
+}): boolean;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var resultFilesystem = require('../cache/resultFilesystem.js');
+var matchesNativeCompilerSnapshotFilesystem = require('../filesystem/matchesNativeCompilerSnapshotFilesystem.js');
+var compilerSnapshotFailureClassifier = require('./compilerSnapshotFailureClassifier.js');
+
+/**
+ * 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.
+ */
+function canDeliverCompilerSnapshot(props) {
+    const { result, failures } = props;
+    if (props.adopted ||
+        result.type !== "success" ||
+        !result.graph?.compilationSnapshot ||
+        !matchesNativeCompilerSnapshotFilesystem.matchesNativeCompilerSnapshotFilesystem(resultFilesystem.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.compilerSnapshotFailureClassifier(result, props.projectRoot);
+    return failures.omitted === 0 && failures.entries.every(classify);
+}
+
+exports.canDeliverCompilerSnapshot = canDeliverCompilerSnapshot;
+//# sourceMappingURL=canDeliverCompilerSnapshot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canDeliverCompilerSnapshot.js","sources":["../../../../src/core/transform/generation/canDeliverCompilerSnapshot.ts"],"sourcesContent":[null],"names":["matchesNativeCompilerSnapshotFilesystem","resultFilesystem","compilerSnapshotFailureClassifier"],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,0BAA0B,CAAC,KAK1C,EAAA;AACC,IAAA,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK;IAClC,IACE,KAAK,CAAC,OAAO;QACb,MAAM,CAAC,IAAI,KAAK,SAAS;AACzB,QAAA,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB;AAClC,QAAA,CAACA,+EAAuC,CAACC,iCAAgB,CAAC,MAAM,CAAC,CAAC;QAClE,MAAM,CAAC,oBAAoB,KAAK,KAAK;AACrC,QAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC;AAC7D,QAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC;AAC/D,QAAA,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;AAE7B,QAAA,OAAO,KAAK;AACd,IAAA,IAAI,QAAQ,CAAC,kBAAkB,KAAK,SAAS;QAC3C,OAAO,QAAQ,CAAC,kBAAkB;IACpC,MAAM,QAAQ,GAAGC,mEAAiC,CAChD,MAAM,EACN,KAAK,CAAC,WAAW,CACjB;AACF,IAAA,OAAO,QAAQ,CAAC,OAAO,KAAK,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;AACnE;;;;"}

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

@@ -0,0 +1,40 @@
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { matchesNativeCompilerSnapshotFilesystem } from '../filesystem/matchesNativeCompilerSnapshotFilesystem.mjs';
+import { compilerSnapshotFailureClassifier } from './compilerSnapshotFailureClassifier.mjs';
+
+/**
+ * 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.
+ */
+function canDeliverCompilerSnapshot(props) {
+    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);
+}
+
+export { canDeliverCompilerSnapshot };
+//# sourceMappingURL=canDeliverCompilerSnapshot.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canDeliverCompilerSnapshot.mjs","sources":["../../../../src/core/transform/generation/canDeliverCompilerSnapshot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,0BAA0B,CAAC,KAK1C,EAAA;AACC,IAAA,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK;IAClC,IACE,KAAK,CAAC,OAAO;QACb,MAAM,CAAC,IAAI,KAAK,SAAS;AACzB,QAAA,CAAC,MAAM,CAAC,KAAK,EAAE,mBAAmB;AAClC,QAAA,CAAC,uCAAuC,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAClE,MAAM,CAAC,oBAAoB,KAAK,KAAK;AACrC,QAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC;AAC7D,QAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC;AAC/D,QAAA,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;AAE7B,QAAA,OAAO,KAAK;AACd,IAAA,IAAI,QAAQ,CAAC,kBAAkB,KAAK,SAAS;QAC3C,OAAO,QAAQ,CAAC,kBAAkB;IACpC,MAAM,QAAQ,GAAG,iCAAiC,CAChD,MAAM,EACN,KAAK,CAAC,WAAW,CACjB;AACF,IAAA,OAAO,QAAQ,CAAC,OAAO,KAAK,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;AACnE;;;;"}