@ttsc/unplugin 0.31.0 → 0.31.1

package/lib/core/observer/openIsolatedRecursiveWatch.d.ts

@@ -2,18 +2,17 @@
  * Open one recursive observer inside the transform core's isolated watch broker
  * instead of the host process.
  *
- * On Windows, Node's fs-event backend can abort the process that owns a watch,
- * for instance with `Assertion failed: !_wcsnicmp(filename, dir, dirlen)` in
- * `src\win\fs-event.c` (samchon/ttsc#1411). On macOS, libuv serves every
- * directory watch of a loop through one FSEventStream and re-creates it
- * whenever any watch opens or closes, losing the events in between
- * (samchon/ttsc#1418), where the broker opens one stream per watch. The
- * observer's scopes get the isolation the transform core's trackers have,
- * through the same registration (`openBrokeredWatch`) with a sink of their own
- * that forwards events (samchon/ttsc#1485). Attributed events reach `listener`
- * with a joined caller-directory path; unattributed events use null. A failed
- * registration reaches `onError`, which hands the scope's entries to the
- * bounded poll.
+ * On Windows, ttsc's direct native helper excludes access-only notifications
+ * and reports actual mutation, loss and failure through the same broker sink.
+ * On macOS, libuv serves every directory watch of a loop through one
+ * FSEventStream and re-creates it whenever any watch opens or closes, losing
+ * the events in between (samchon/ttsc#1418), where the broker opens one stream
+ * per watch. The observer's scopes get the isolation the transform core's
+ * trackers have, through the same registration (`openBrokeredWatch`) with a
+ * sink of their own that forwards events (samchon/ttsc#1485). Attributed events
+ * reach `listener` with a joined caller-directory path; unattributed events use
+ * null. A failed registration reaches `onError`, which hands the scope's
+ * entries to the bounded poll.
  *
  * Registration completes asynchronously, and FSEvents can later drop events
  * (samchon/ttsc#1425). Until the broker confirms the watch, and whenever it

package/lib/core/observer/openIsolatedRecursiveWatch.js

@@ -8,18 +8,17 @@ var openBrokeredWatch = require('../transform/tracker/broker/openBrokeredWatch.j
  * Open one recursive observer inside the transform core's isolated watch broker
  * instead of the host process.
  *
- * On Windows, Node's fs-event backend can abort the process that owns a watch,
- * for instance with `Assertion failed: !_wcsnicmp(filename, dir, dirlen)` in
- * `src\win\fs-event.c` (samchon/ttsc#1411). On macOS, libuv serves every
- * directory watch of a loop through one FSEventStream and re-creates it
- * whenever any watch opens or closes, losing the events in between
- * (samchon/ttsc#1418), where the broker opens one stream per watch. The
- * observer's scopes get the isolation the transform core's trackers have,
- * through the same registration (`openBrokeredWatch`) with a sink of their own
- * that forwards events (samchon/ttsc#1485). Attributed events reach `listener`
- * with a joined caller-directory path; unattributed events use null. A failed
- * registration reaches `onError`, which hands the scope's entries to the
- * bounded poll.
+ * On Windows, ttsc's direct native helper excludes access-only notifications
+ * and reports actual mutation, loss and failure through the same broker sink.
+ * On macOS, libuv serves every directory watch of a loop through one
+ * FSEventStream and re-creates it whenever any watch opens or closes, losing
+ * the events in between (samchon/ttsc#1418), where the broker opens one stream
+ * per watch. The observer's scopes get the isolation the transform core's
+ * trackers have, through the same registration (`openBrokeredWatch`) with a
+ * sink of their own that forwards events (samchon/ttsc#1485). Attributed events
+ * reach `listener` with a joined caller-directory path; unattributed events use
+ * null. A failed registration reaches `onError`, which hands the scope's
+ * entries to the bounded poll.
  *
  * Registration completes asynchronously, and FSEvents can later drop events
  * (samchon/ttsc#1425). Until the broker confirms the watch, and whenever it

package/lib/core/observer/openIsolatedRecursiveWatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"openIsolatedRecursiveWatch.js","sources":["../../../src/core/observer/openIsolatedRecursiveWatch.ts"],"sourcesContent":[null],"names":["openBrokeredWatch","DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACG,SAAU,0BAA0B,CACxC,IAAY,EACZ,QAA0D,EAC1D,OAAmB,EACnB,MAAuC,EACvC,SAAkB,EAAA;IAElB,IAAI,MAAM,GAAG,KAAK;IAClB,IAAI,MAAM,GAAG,KAAK;IAClB,MAAM,OAAO,GAAG,MAAW;AACzB,QAAA,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;AAAE,YAAA,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;AAClD,IAAA,CAAC;AACD,IAAA,MAAM,KAAK,GAAGA,mCAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE;AACtE,QAAA,SAAS,EAAE,IAAI;;;AAGf,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,UAAU,EAAEC,2DAA6B;AACzC,QAAA,IAAI,SAAS,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AACjD,QAAA,IAAI,EAAE;YACJ,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAI;gBACxC,IAAI,CAAC,MAAM,EAAE;oBACX,QAAQ,CACN,SAAS,EACT,QAAQ,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAC1D;gBACH;YACF,CAAC;YACD,MAAM,EAAE,MAAK;gBACX,IAAI,MAAM,IAAI,MAAM;oBAAE;gBACtB,MAAM,GAAG,IAAI;AACb,gBAAA,OAAO,EAAE;YACX,CAAC;AACD,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,OAAO;AACrB,YAAA,QAAQ,EAAE,MAAM,SAAS;AAC1B,SAAA;AACF,KAAA,CAAC;IACF,KAAK,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;IAC9B,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,GAAG,IAAI;YACb,KAAK,CAAC,KAAK,EAAE;QACf,CAAC;KACF;AACH;;;;"}
+{"version":3,"file":"openIsolatedRecursiveWatch.js","sources":["../../../src/core/observer/openIsolatedRecursiveWatch.ts"],"sourcesContent":[null],"names":["openBrokeredWatch","DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACG,SAAU,0BAA0B,CACxC,IAAY,EACZ,QAA0D,EAC1D,OAAmB,EACnB,MAAuC,EACvC,SAAkB,EAAA;IAElB,IAAI,MAAM,GAAG,KAAK;IAClB,IAAI,MAAM,GAAG,KAAK;IAClB,MAAM,OAAO,GAAG,MAAW;AACzB,QAAA,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;AAAE,YAAA,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;AAClD,IAAA,CAAC;AACD,IAAA,MAAM,KAAK,GAAGA,mCAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE;AACtE,QAAA,SAAS,EAAE,IAAI;;;AAGf,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,UAAU,EAAEC,2DAA6B;AACzC,QAAA,IAAI,SAAS,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AACjD,QAAA,IAAI,EAAE;YACJ,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAI;gBACxC,IAAI,CAAC,MAAM,EAAE;oBACX,QAAQ,CACN,SAAS,EACT,QAAQ,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAC1D;gBACH;YACF,CAAC;YACD,MAAM,EAAE,MAAK;gBACX,IAAI,MAAM,IAAI,MAAM;oBAAE;gBACtB,MAAM,GAAG,IAAI;AACb,gBAAA,OAAO,EAAE;YACX,CAAC;AACD,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,OAAO;AACrB,YAAA,QAAQ,EAAE,MAAM,SAAS;AAC1B,SAAA;AACF,KAAA,CAAC;IACF,KAAK,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;IAC9B,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,GAAG,IAAI;YACb,KAAK,CAAC,KAAK,EAAE;QACf,CAAC;KACF;AACH;;;;"}

package/lib/core/observer/openIsolatedRecursiveWatch.mjs

@@ -6,18 +6,17 @@ import { openBrokeredWatch } from '../transform/tracker/broker/openBrokeredWatch
  * Open one recursive observer inside the transform core's isolated watch broker
  * instead of the host process.
  *
- * On Windows, Node's fs-event backend can abort the process that owns a watch,
- * for instance with `Assertion failed: !_wcsnicmp(filename, dir, dirlen)` in
- * `src\win\fs-event.c` (samchon/ttsc#1411). On macOS, libuv serves every
- * directory watch of a loop through one FSEventStream and re-creates it
- * whenever any watch opens or closes, losing the events in between
- * (samchon/ttsc#1418), where the broker opens one stream per watch. The
- * observer's scopes get the isolation the transform core's trackers have,
- * through the same registration (`openBrokeredWatch`) with a sink of their own
- * that forwards events (samchon/ttsc#1485). Attributed events reach `listener`
- * with a joined caller-directory path; unattributed events use null. A failed
- * registration reaches `onError`, which hands the scope's entries to the
- * bounded poll.
+ * On Windows, ttsc's direct native helper excludes access-only notifications
+ * and reports actual mutation, loss and failure through the same broker sink.
+ * On macOS, libuv serves every directory watch of a loop through one
+ * FSEventStream and re-creates it whenever any watch opens or closes, losing
+ * the events in between (samchon/ttsc#1418), where the broker opens one stream
+ * per watch. The observer's scopes get the isolation the transform core's
+ * trackers have, through the same registration (`openBrokeredWatch`) with a
+ * sink of their own that forwards events (samchon/ttsc#1485). Attributed events
+ * reach `listener` with a joined caller-directory path; unattributed events use
+ * null. A failed registration reaches `onError`, which hands the scope's
+ * entries to the bounded poll.
  *
  * Registration completes asynchronously, and FSEvents can later drop events
  * (samchon/ttsc#1425). Until the broker confirms the watch, and whenever it

package/lib/core/observer/openIsolatedRecursiveWatch.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"openIsolatedRecursiveWatch.mjs","sources":["../../../src/core/observer/openIsolatedRecursiveWatch.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACG,SAAU,0BAA0B,CACxC,IAAY,EACZ,QAA0D,EAC1D,OAAmB,EACnB,MAAuC,EACvC,SAAkB,EAAA;IAElB,IAAI,MAAM,GAAG,KAAK;IAClB,IAAI,MAAM,GAAG,KAAK;IAClB,MAAM,OAAO,GAAG,MAAW;AACzB,QAAA,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;AAAE,YAAA,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;AAClD,IAAA,CAAC;AACD,IAAA,MAAM,KAAK,GAAG,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE;AACtE,QAAA,SAAS,EAAE,IAAI;;;AAGf,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,UAAU,EAAE,6BAA6B;AACzC,QAAA,IAAI,SAAS,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AACjD,QAAA,IAAI,EAAE;YACJ,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAI;gBACxC,IAAI,CAAC,MAAM,EAAE;oBACX,QAAQ,CACN,SAAS,EACT,QAAQ,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAC1D;gBACH;YACF,CAAC;YACD,MAAM,EAAE,MAAK;gBACX,IAAI,MAAM,IAAI,MAAM;oBAAE;gBACtB,MAAM,GAAG,IAAI;AACb,gBAAA,OAAO,EAAE;YACX,CAAC;AACD,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,OAAO;AACrB,YAAA,QAAQ,EAAE,MAAM,SAAS;AAC1B,SAAA;AACF,KAAA,CAAC;IACF,KAAK,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;IAC9B,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,GAAG,IAAI;YACb,KAAK,CAAC,KAAK,EAAE;QACf,CAAC;KACF;AACH;;;;"}
+{"version":3,"file":"openIsolatedRecursiveWatch.mjs","sources":["../../../src/core/observer/openIsolatedRecursiveWatch.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACG,SAAU,0BAA0B,CACxC,IAAY,EACZ,QAA0D,EAC1D,OAAmB,EACnB,MAAuC,EACvC,SAAkB,EAAA;IAElB,IAAI,MAAM,GAAG,KAAK;IAClB,IAAI,MAAM,GAAG,KAAK;IAClB,MAAM,OAAO,GAAG,MAAW;AACzB,QAAA,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;AAAE,YAAA,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;AAClD,IAAA,CAAC;AACD,IAAA,MAAM,KAAK,GAAG,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE;AACtE,QAAA,SAAS,EAAE,IAAI;;;AAGf,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,UAAU,EAAE,6BAA6B;AACzC,QAAA,IAAI,SAAS,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AACjD,QAAA,IAAI,EAAE;YACJ,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,KAAI;gBACxC,IAAI,CAAC,MAAM,EAAE;oBACX,QAAQ,CACN,SAAS,EACT,QAAQ,KAAK,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAC1D;gBACH;YACF,CAAC;YACD,MAAM,EAAE,MAAK;gBACX,IAAI,MAAM,IAAI,MAAM;oBAAE;gBACtB,MAAM,GAAG,IAAI;AACb,gBAAA,OAAO,EAAE;YACX,CAAC;AACD,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,OAAO;AACrB,YAAA,QAAQ,EAAE,MAAM,SAAS;AAC1B,SAAA;AACF,KAAA,CAAC;IACF,KAAK,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;IAC9B,OAAO;QACL,KAAK,EAAE,MAAK;YACV,MAAM,GAAG,IAAI;YACb,KAAK,CAAC,KAAK,EAAE;QACf,CAAC;KACF;AACH;;;;"}

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

@@ -205,11 +205,20 @@ export interface TtscCachedProjectTransform {
     projectSnapshotComplete?: boolean;
     /**
      * A locally admitted answer with incomplete host observations cannot be
-     * retained for resident, shared or persistent reuse. Successful answers need
-     * only explicit unavailable observations; diagnostic admission keeps its
-     * existing current-verdict policy. This flag never grants admission itself.
+     * retained for shared or persistent reuse. A separately admitted coherent
+     * local success may share first deliveries only in its explicit nonwatching
+     * pass (passDeliveryOnly). Successful answers need only explicit unavailable
+     * observations; diagnostic admission keeps its existing current-verdict
+     * policy. This flag never grants admission itself.
      */
     freshDeliveryOnly?: boolean;
+    /**
+     * Coherent local success whose only missing authority is host observation.
+     * WARNING (#1713): this grants neither persistent nor pooled reuse. The
+     * common proof owner requires an explicit nonwatching pass, a recorded
+     * source, first delivery and actual host-cache withdrawal on every delivery.
+     */
+    passDeliveryOnly?: boolean;
     /** Absolute path to the directory that owns the tsconfig. */
     projectRoot: string;
     /**

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

@@ -205,11 +205,20 @@ export interface TtscCachedProjectTransform {
     projectSnapshotComplete?: boolean;
     /**
      * A locally admitted answer with incomplete host observations cannot be
-     * retained for resident, shared or persistent reuse. Successful answers need
-     * only explicit unavailable observations; diagnostic admission keeps its
-     * existing current-verdict policy. This flag never grants admission itself.
+     * retained for shared or persistent reuse. A separately admitted coherent
+     * local success may share first deliveries only in its explicit nonwatching
+     * pass (passDeliveryOnly). Successful answers need only explicit unavailable
+     * observations; diagnostic admission keeps its existing current-verdict
+     * policy. This flag never grants admission itself.
      */
     freshDeliveryOnly?: boolean;
+    /**
+     * Coherent local success whose only missing authority is host observation.
+     * WARNING (#1713): this grants neither persistent nor pooled reuse. The
+     * common proof owner requires an explicit nonwatching pass, a recorded
+     * source, first delivery and actual host-cache withdrawal on every delivery.
+     */
+    passDeliveryOnly?: boolean;
     /** Absolute path to the directory that owns the tsconfig. */
     projectRoot: string;
     /**

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

@@ -205,11 +205,20 @@ export interface TtscCachedProjectTransform {
     projectSnapshotComplete?: boolean;
     /**
      * A locally admitted answer with incomplete host observations cannot be
-     * retained for resident, shared or persistent reuse. Successful answers need
-     * only explicit unavailable observations; diagnostic admission keeps its
-     * existing current-verdict policy. This flag never grants admission itself.
+     * retained for shared or persistent reuse. A separately admitted coherent
+     * local success may share first deliveries only in its explicit nonwatching
+     * pass (passDeliveryOnly). Successful answers need only explicit unavailable
+     * observations; diagnostic admission keeps its existing current-verdict
+     * policy. This flag never grants admission itself.
      */
     freshDeliveryOnly?: boolean;
+    /**
+     * Coherent local success whose only missing authority is host observation.
+     * WARNING (#1713): this grants neither persistent nor pooled reuse. The
+     * common proof owner requires an explicit nonwatching pass, a recorded
+     * source, first delivery and actual host-cache withdrawal on every delivery.
+     */
+    passDeliveryOnly?: boolean;
     /** Absolute path to the directory that owns the tsconfig. */
     projectRoot: string;
     /**

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

@@ -1,3 +1,4 @@
+import type { TtscGenerationProof } from "../validation/TtscGenerationProof.cjs";
 import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
 import type { TtscTransformCache } from "./TtscTransformCache.cjs";
 /**
@@ -37,4 +38,5 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

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

@@ -1,3 +1,4 @@
+import type { TtscGenerationProof } from "../validation/TtscGenerationProof.mjs";
 import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.mjs";
 import type { TtscTransformCache } from "./TtscTransformCache.mjs";
 /**
@@ -37,4 +38,5 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

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

@@ -1,3 +1,4 @@
+import type { TtscGenerationProof } from "../validation/TtscGenerationProof";
 import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
 import type { TtscTransformCache } from "./TtscTransformCache";
 /**
@@ -37,4 +38,5 @@ export declare function selectCachedGenerationAction(props: {
     generation: Promise<TtscCachedProjectTransform>;
     key: string;
     source: string;
+    proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture";

package/lib/core/transform/cache/selectCachedGenerationAction.js

@@ -40,7 +40,7 @@ function selectCachedGenerationAction(props) {
         projectRoot: props.cached.projectRoot,
         result: props.cached.result,
     }) &&
-        matchesCachedSource.matchesCachedSource(props.cached, props.file, props.source, props.epoch)) {
+        matchesCachedSource.matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof)) {
         return "serve";
     }
     evictGeneration.evictGeneration(props.cache, props.key, props.generation);

package/lib/core/transform/cache/selectCachedGenerationAction.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectCachedGenerationAction.js","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":["isVolatileFile","envelopeDerivation","matchesCachedSource","evictGeneration"],"mappings":";;;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAQ5C,EAAA;IACC,IACE,CAACA,6BAAc,CAACC,qCAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;AACF,QAAAC,uCAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,EACxE;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAAC,+BAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}
+{"version":3,"file":"selectCachedGenerationAction.js","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":["isVolatileFile","envelopeDerivation","matchesCachedSource","evictGeneration"],"mappings":";;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAS5C,EAAA;IACC,IACE,CAACA,6BAAc,CAACC,qCAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACFC,uCAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,CACZ,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAAC,+BAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}

package/lib/core/transform/cache/selectCachedGenerationAction.mjs

@@ -38,7 +38,7 @@ function selectCachedGenerationAction(props) {
         projectRoot: props.cached.projectRoot,
         result: props.cached.result,
     }) &&
-        matchesCachedSource(props.cached, props.file, props.source, props.epoch)) {
+        matchesCachedSource(props.cached, props.file, props.source, props.epoch, props.proof)) {
         return "serve";
     }
     evictGeneration(props.cache, props.key, props.generation);

package/lib/core/transform/cache/selectCachedGenerationAction.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"selectCachedGenerationAction.mjs","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAQ5C,EAAA;IACC,IACE,CAAC,cAAc,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;AACF,QAAA,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,EACxE;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}
+{"version":3,"file":"selectCachedGenerationAction.mjs","sources":["../../../../src/core/transform/cache/selectCachedGenerationAction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,4BAA4B,CAAC,KAS5C,EAAA;IACC,IACE,CAAC,cAAc,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAChD,IAAI,EAAE,KAAK,CAAC,IAAI;AAChB,QAAA,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;AACrC,QAAA,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;KAC5B,CAAC;QACF,mBAAmB,CACjB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,KAAK,CACZ,EACD;AACA,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,CAAC;IACzD,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,OAAO,GAAG,SAAS;AACxE;;;;"}

package/lib/core/transform/deliverCachedTransform.d.cts

@@ -0,0 +1,36 @@
+import type { TtscCachedProjectTransform } from "./cache/TtscCachedProjectTransform.cjs";
+import type { TtscTransformCache } from "./cache/TtscTransformCache.cjs";
+import type { TtscTransformHooks } from "./watch/TtscTransformHooks.cjs";
+import type { TtscWatchSelection } from "./watch/TtscWatchSelection.cjs";
+/**
+ * Deliver both captured and reused generations through one failure boundary.
+ *
+ * WARNING (#1713): host capabilities and callbacks apply to every delivery,
+ * including cache hits. Incomplete local results must never survive a failed
+ * handoff or acquire a persistent record. Stable ordinary generations retain
+ * their existing callback-failure recovery policy.
+ *
+ * A missing program output is an admitted absence: notify the same selection
+ * inputs and return control to the host. Compile failure retains its existing
+ * terminal policy through selectOrEvict and reports repair inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Captured and reused results share lifecycle admission, output selection, diagnostics and host handoff; incomplete ownership is evicted on any failed delivery effect, while missing output remains a host fallthrough.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous boundary removes duplicate initial/cache-hit delivery paths and their divergent callback and cleanup rules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing outputs never manufacture transformed bytes or reusable observation authority; incomplete handoff failure cannot leave an owner for a sibling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states per-delivery capability, callback failure, missing-output and compile-failure responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native identities and host spellings remain delegated to the generation's existing output/watch owners.
+ * @evidence contracts/performance.md#efficient-algorithms Selection uses generation indexes; diagnostics, output/map work and current host callbacks remain necessary per delivery. Watch input and record derivation retain their owning population costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial and reused answers share the exact same operation, while generation-owned indexes and the pass-qualified compiled result retain their separate validity premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh-only admission releases capture resources; failed incomplete delivery evicts only its exact Promise. Ordinary selection/terminal and host lifecycle owners retain their established resource policy.
+ */
+export declare function deliverCachedTransform(props: {
+    cache: TtscTransformCache | undefined;
+    cached: TtscCachedProjectTransform;
+    generation: Promise<TtscCachedProjectTransform>;
+    key: string;
+    epoch: number | undefined;
+    file: string;
+    source: string;
+    hooks: TtscTransformHooks | undefined;
+    selection: TtscWatchSelection;
+}): import("./TtscTransformResult.cjs").TtscTransformResult | undefined;

package/lib/core/transform/deliverCachedTransform.d.mts

@@ -0,0 +1,36 @@
+import type { TtscCachedProjectTransform } from "./cache/TtscCachedProjectTransform.mjs";
+import type { TtscTransformCache } from "./cache/TtscTransformCache.mjs";
+import type { TtscTransformHooks } from "./watch/TtscTransformHooks.mjs";
+import type { TtscWatchSelection } from "./watch/TtscWatchSelection.mjs";
+/**
+ * Deliver both captured and reused generations through one failure boundary.
+ *
+ * WARNING (#1713): host capabilities and callbacks apply to every delivery,
+ * including cache hits. Incomplete local results must never survive a failed
+ * handoff or acquire a persistent record. Stable ordinary generations retain
+ * their existing callback-failure recovery policy.
+ *
+ * A missing program output is an admitted absence: notify the same selection
+ * inputs and return control to the host. Compile failure retains its existing
+ * terminal policy through selectOrEvict and reports repair inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Captured and reused results share lifecycle admission, output selection, diagnostics and host handoff; incomplete ownership is evicted on any failed delivery effect, while missing output remains a host fallthrough.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous boundary removes duplicate initial/cache-hit delivery paths and their divergent callback and cleanup rules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing outputs never manufacture transformed bytes or reusable observation authority; incomplete handoff failure cannot leave an owner for a sibling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states per-delivery capability, callback failure, missing-output and compile-failure responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native identities and host spellings remain delegated to the generation's existing output/watch owners.
+ * @evidence contracts/performance.md#efficient-algorithms Selection uses generation indexes; diagnostics, output/map work and current host callbacks remain necessary per delivery. Watch input and record derivation retain their owning population costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial and reused answers share the exact same operation, while generation-owned indexes and the pass-qualified compiled result retain their separate validity premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh-only admission releases capture resources; failed incomplete delivery evicts only its exact Promise. Ordinary selection/terminal and host lifecycle owners retain their established resource policy.
+ */
+export declare function deliverCachedTransform(props: {
+    cache: TtscTransformCache | undefined;
+    cached: TtscCachedProjectTransform;
+    generation: Promise<TtscCachedProjectTransform>;
+    key: string;
+    epoch: number | undefined;
+    file: string;
+    source: string;
+    hooks: TtscTransformHooks | undefined;
+    selection: TtscWatchSelection;
+}): import("./TtscTransformResult.mjs").TtscTransformResult | undefined;

package/lib/core/transform/deliverCachedTransform.d.ts

@@ -0,0 +1,36 @@
+import type { TtscCachedProjectTransform } from "./cache/TtscCachedProjectTransform";
+import type { TtscTransformCache } from "./cache/TtscTransformCache";
+import type { TtscTransformHooks } from "./watch/TtscTransformHooks";
+import type { TtscWatchSelection } from "./watch/TtscWatchSelection";
+/**
+ * Deliver both captured and reused generations through one failure boundary.
+ *
+ * WARNING (#1713): host capabilities and callbacks apply to every delivery,
+ * including cache hits. Incomplete local results must never survive a failed
+ * handoff or acquire a persistent record. Stable ordinary generations retain
+ * their existing callback-failure recovery policy.
+ *
+ * A missing program output is an admitted absence: notify the same selection
+ * inputs and return control to the host. Compile failure retains its existing
+ * terminal policy through selectOrEvict and reports repair inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Captured and reused results share lifecycle admission, output selection, diagnostics and host handoff; incomplete ownership is evicted on any failed delivery effect, while missing output remains a host fallthrough.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous boundary removes duplicate initial/cache-hit delivery paths and their divergent callback and cleanup rules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing outputs never manufacture transformed bytes or reusable observation authority; incomplete handoff failure cannot leave an owner for a sibling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states per-delivery capability, callback failure, missing-output and compile-failure responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native identities and host spellings remain delegated to the generation's existing output/watch owners.
+ * @evidence contracts/performance.md#efficient-algorithms Selection uses generation indexes; diagnostics, output/map work and current host callbacks remain necessary per delivery. Watch input and record derivation retain their owning population costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial and reused answers share the exact same operation, while generation-owned indexes and the pass-qualified compiled result retain their separate validity premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh-only admission releases capture resources; failed incomplete delivery evicts only its exact Promise. Ordinary selection/terminal and host lifecycle owners retain their established resource policy.
+ */
+export declare function deliverCachedTransform(props: {
+    cache: TtscTransformCache | undefined;
+    cached: TtscCachedProjectTransform;
+    generation: Promise<TtscCachedProjectTransform>;
+    key: string;
+    epoch: number | undefined;
+    file: string;
+    source: string;
+    hooks: TtscTransformHooks | undefined;
+    selection: TtscWatchSelection;
+}): import("./TtscTransformResult").TtscTransformResult | undefined;

package/lib/core/transform/deliverCachedTransform.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var evictGeneration = require('./cache/evictGeneration.js');
+var selectOrEvict = require('./cache/selectOrEvict.js');
+var reportMissingProgramOutput = require('./diagnostics/reportMissingProgramOutput.js');
+var reportSuccessDiagnostics = require('./diagnostics/reportSuccessDiagnostics.js');
+var TtscMissingProgramOutputError = require('./errors/TtscMissingProgramOutputError.js');
+var createTransformResult = require('./utils/createTransformResult.js');
+var TtscGenerationProof = require('./validation/TtscGenerationProof.js');
+var markCachedSourceServed = require('./validation/markCachedSourceServed.js');
+var notifyFailedGenerationInputs = require('./watch/notifyFailedGenerationInputs.js');
+var notifyVolatileDelivery = require('./watch/notifyVolatileDelivery.js');
+var notifyWatchInputs = require('./watch/notifyWatchInputs.js');
+
+/**
+ * Deliver both captured and reused generations through one failure boundary.
+ *
+ * WARNING (#1713): host capabilities and callbacks apply to every delivery,
+ * including cache hits. Incomplete local results must never survive a failed
+ * handoff or acquire a persistent record. Stable ordinary generations retain
+ * their existing callback-failure recovery policy.
+ *
+ * A missing program output is an admitted absence: notify the same selection
+ * inputs and return control to the host. Compile failure retains its existing
+ * terminal policy through selectOrEvict and reports repair inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Captured and reused results share lifecycle admission, output selection, diagnostics and host handoff; incomplete ownership is evicted on any failed delivery effect, while missing output remains a host fallthrough.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous boundary removes duplicate initial/cache-hit delivery paths and their divergent callback and cleanup rules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing outputs never manufacture transformed bytes or reusable observation authority; incomplete handoff failure cannot leave an owner for a sibling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states per-delivery capability, callback failure, missing-output and compile-failure responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native identities and host spellings remain delegated to the generation's existing output/watch owners.
+ * @evidence contracts/performance.md#efficient-algorithms Selection uses generation indexes; diagnostics, output/map work and current host callbacks remain necessary per delivery. Watch input and record derivation retain their owning population costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial and reused answers share the exact same operation, while generation-owned indexes and the pass-qualified compiled result retain their separate validity premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh-only admission releases capture resources; failed incomplete delivery evicts only its exact Promise. Ordinary selection/terminal and host lifecycle owners retain their established resource policy.
+ */
+function deliverCachedTransform(props) {
+    const { cache, cached, generation, key, epoch, file, source, hooks, selection, } = props;
+    try {
+        TtscGenerationProof.TtscGenerationProof.admitFreshOnly(cached, cache, key, generation, epoch, hooks);
+        reportSuccessDiagnostics.reportSuccessDiagnostics(cached, epoch);
+        let output;
+        try {
+            output = selectOrEvict.selectOrEvict(cache, key, generation, epoch, {
+                file,
+                projectRoot: cached.projectRoot,
+                result: cached.result,
+                tsconfig: cached.tsconfig,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof TtscMissingProgramOutputError.TtscMissingProgramOutputError)) {
+                notifyFailedGenerationInputs.notifyFailedGenerationInputs(hooks, cached, file, selection);
+                throw error;
+            }
+            reportMissingProgramOutput.reportMissingProgramOutput(cached, error, epoch);
+            notifyWatchInputs.notifyWatchInputs(hooks, cached, file, selection);
+            markCachedSourceServed.markCachedSourceServed(cached, file);
+            return undefined;
+        }
+        notifyWatchInputs.notifyWatchInputs(hooks, cached, file, selection);
+        markCachedSourceServed.markCachedSourceServed(cached, file);
+        notifyVolatileDelivery.notifyVolatileDelivery(hooks, cached, file);
+        return createTransformResult.createTransformResult(file, source, output);
+    }
+    catch (error) {
+        if (cached.freshDeliveryOnly === true)
+            evictGeneration.evictGeneration(cache, key, generation);
+        throw error;
+    }
+}
+
+exports.deliverCachedTransform = deliverCachedTransform;
+//# sourceMappingURL=deliverCachedTransform.js.map

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

@@ -0,0 +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;;;;"}

package/lib/core/transform/deliverCachedTransform.mjs

@@ -0,0 +1,71 @@
+import { evictGeneration } from './cache/evictGeneration.mjs';
+import { selectOrEvict } from './cache/selectOrEvict.mjs';
+import { reportMissingProgramOutput } from './diagnostics/reportMissingProgramOutput.mjs';
+import { reportSuccessDiagnostics } from './diagnostics/reportSuccessDiagnostics.mjs';
+import { TtscMissingProgramOutputError } from './errors/TtscMissingProgramOutputError.mjs';
+import { createTransformResult } from './utils/createTransformResult.mjs';
+import { TtscGenerationProof } from './validation/TtscGenerationProof.mjs';
+import { markCachedSourceServed } from './validation/markCachedSourceServed.mjs';
+import { notifyFailedGenerationInputs } from './watch/notifyFailedGenerationInputs.mjs';
+import { notifyVolatileDelivery } from './watch/notifyVolatileDelivery.mjs';
+import { notifyWatchInputs } from './watch/notifyWatchInputs.mjs';
+
+/**
+ * Deliver both captured and reused generations through one failure boundary.
+ *
+ * WARNING (#1713): host capabilities and callbacks apply to every delivery,
+ * including cache hits. Incomplete local results must never survive a failed
+ * handoff or acquire a persistent record. Stable ordinary generations retain
+ * their existing callback-failure recovery policy.
+ *
+ * A missing program output is an admitted absence: notify the same selection
+ * inputs and return control to the host. Compile failure retains its existing
+ * terminal policy through selectOrEvict and reports repair inputs.
+ *
+ * @evidence contracts/common.md#principled-implementation Captured and reused results share lifecycle admission, output selection, diagnostics and host handoff; incomplete ownership is evicted on any failed delivery effect, while missing output remains a host fallthrough.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous boundary removes duplicate initial/cache-hit delivery paths and their divergent callback and cleanup rules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing outputs never manufacture transformed bytes or reusable observation authority; incomplete handoff failure cannot leave an owner for a sibling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states per-delivery capability, callback failure, missing-output and compile-failure responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native identities and host spellings remain delegated to the generation's existing output/watch owners.
+ * @evidence contracts/performance.md#efficient-algorithms Selection uses generation indexes; diagnostics, output/map work and current host callbacks remain necessary per delivery. Watch input and record derivation retain their owning population costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Initial and reused answers share the exact same operation, while generation-owned indexes and the pass-qualified compiled result retain their separate validity premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Fresh-only admission releases capture resources; failed incomplete delivery evicts only its exact Promise. Ordinary selection/terminal and host lifecycle owners retain their established resource policy.
+ */
+function deliverCachedTransform(props) {
+    const { cache, cached, generation, key, epoch, file, source, hooks, selection, } = props;
+    try {
+        TtscGenerationProof.admitFreshOnly(cached, cache, key, generation, epoch, hooks);
+        reportSuccessDiagnostics(cached, epoch);
+        let output;
+        try {
+            output = selectOrEvict(cache, key, generation, epoch, {
+                file,
+                projectRoot: cached.projectRoot,
+                result: cached.result,
+                tsconfig: cached.tsconfig,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof TtscMissingProgramOutputError)) {
+                notifyFailedGenerationInputs(hooks, cached, file, selection);
+                throw error;
+            }
+            reportMissingProgramOutput(cached, error, epoch);
+            notifyWatchInputs(hooks, cached, file, selection);
+            markCachedSourceServed(cached, file);
+            return undefined;
+        }
+        notifyWatchInputs(hooks, cached, file, selection);
+        markCachedSourceServed(cached, file);
+        notifyVolatileDelivery(hooks, cached, file);
+        return createTransformResult(file, source, output);
+    }
+    catch (error) {
+        if (cached.freshDeliveryOnly === true)
+            evictGeneration(cache, key, generation);
+        throw error;
+    }
+}
+
+export { deliverCachedTransform };
+//# sourceMappingURL=deliverCachedTransform.mjs.map

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

@@ -0,0 +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;;;;"}

package/lib/core/transform/envelope/selectDeclaredProjectInputKeys.d.cts

@@ -21,8 +21,8 @@ import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
  *   Visits each reported occurrence in graph endpoints/globals/configs,
  *   candidates, host inputs and dependency arrays. Native resolve, scratch
  *   checks, project-key identity/ancestor/case observations and text hashing
- *   precede each own-key membership test; duplicate declarations still pay
- *   those queries, with native answers shared by the supplied context. Entry
+ *   precede each own-key membership test after lexical deduplication; repeated
+ *   declarations pay resolution but no repeated native classification. Entry
  *   arrays from Object.entries/Object.values follow producer populations,
  *   while the returned set cannot exceed keys present in the project snapshot.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work

package/lib/core/transform/envelope/selectDeclaredProjectInputKeys.d.mts

@@ -21,8 +21,8 @@ import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
  *   Visits each reported occurrence in graph endpoints/globals/configs,
  *   candidates, host inputs and dependency arrays. Native resolve, scratch
  *   checks, project-key identity/ancestor/case observations and text hashing
- *   precede each own-key membership test; duplicate declarations still pay
- *   those queries, with native answers shared by the supplied context. Entry
+ *   precede each own-key membership test after lexical deduplication; repeated
+ *   declarations pay resolution but no repeated native classification. Entry
  *   arrays from Object.entries/Object.values follow producer populations,
  *   while the returned set cannot exceed keys present in the project snapshot.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work

package/lib/core/transform/envelope/selectDeclaredProjectInputKeys.d.ts

@@ -21,8 +21,8 @@ import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
  *   Visits each reported occurrence in graph endpoints/globals/configs,
  *   candidates, host inputs and dependency arrays. Native resolve, scratch
  *   checks, project-key identity/ancestor/case observations and text hashing
- *   precede each own-key membership test; duplicate declarations still pay
- *   those queries, with native answers shared by the supplied context. Entry
+ *   precede each own-key membership test after lexical deduplication; repeated
+ *   declarations pay resolution but no repeated native classification. Entry
  *   arrays from Object.entries/Object.values follow producer populations,
  *   while the returned set cannot exceed keys present in the project snapshot.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work

package/lib/core/transform/envelope/selectDeclaredProjectInputKeys.js

@@ -25,8 +25,8 @@ var isTransformScratchInput = require('../tsconfig/isTransformScratchInput.js');
  *   Visits each reported occurrence in graph endpoints/globals/configs,
  *   candidates, host inputs and dependency arrays. Native resolve, scratch
  *   checks, project-key identity/ancestor/case observations and text hashing
- *   precede each own-key membership test; duplicate declarations still pay
- *   those queries, with native answers shared by the supplied context. Entry
+ *   precede each own-key membership test after lexical deduplication; repeated
+ *   declarations pay resolution but no repeated native classification. Entry
  *   arrays from Object.entries/Object.values follow producer populations,
  *   while the returned set cannot exceed keys present in the project snapshot.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work
@@ -42,10 +42,14 @@ function selectDeclaredProjectInputKeys(props) {
     }
     const graph = props.result.graph;
     const keys = new Set();
+    const seen = new Set();
     const add = (entry) => {
         if (typeof entry !== "string" || entry.length === 0)
             return;
         const absolute = path.resolve(props.projectRoot, entry);
+        if (seen.has(absolute))
+            return;
+        seen.add(absolute);
         if (isTransformScratchInput.isTransformScratchInput(absolute, props.scratchDirectory))
             return;
         const key = toProjectKey.toProjectKey(props.projectRoot, absolute, props.identities);