@ttsc/unplugin 0.31.0 → 0.31.2

package/lib/core/transform/watch/watchInputEvidenceMatchesDisk.js.map

@@ -1 +1 @@
-{"version":3,"file":"watchInputEvidenceMatchesDisk.js","sources":["../../../../src/core/transform/watch/watchInputEvidenceMatchesDisk.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","pluginSourceHolds","matchesGraphInputObservation","createHostPathIdentityContext","sameHostInputRealpath","hostInputRealpath","graphInputStateHash","MISSING_INPUT_STATE","hostInputStateHash"],"mappings":";;;;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAgC,EAChC,aAAgDA,2DAA6B,EAAA;AAE7E,IAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK;IAC5B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY;AAAE,QAAA,OAAO,KAAK;AACrE,IAAA,IAAI;AACF,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE;YAC1B,OAAOC,mCAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC;QAC1D;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY,EAAE;AAChC,YAAA,OAAOC,yDAA4B,CACjC,IAAI,EACJ,KAAK,CAAC,WAAW,EACjB,UAAU,EACVC,2DAA6B,CAAC,UAAU,CAAC,CAC1C;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO,EAAE;AAC3B,YAAA,QACEC,2CAAqB,CACnB,KAAK,CAAC,QAAQ,EACdC,mCAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,EACnCF,2DAA6B,CAAC,UAAU,CAAC,CAC1C;AACD,gBAAA,KAAK,CAAC,IAAI;qBACPG,uCAAmB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAIC,uCAAmB,CAAC;QAEpE;QACA,QACE,KAAK,CAAC,IAAI;aACTC,qCAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAID,uCAAmB,CAAC;IAEjE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}
+{"version":3,"file":"watchInputEvidenceMatchesDisk.js","sources":["../../../../src/core/transform/watch/watchInputEvidenceMatchesDisk.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","pluginSourceHolds","matchesGraphInputObservation","createHostPathIdentityContext","sameHostInputRealpath","hostInputRealpath","graphInputStateHash","MISSING_INPUT_STATE","hostInputStateHash"],"mappings":";;;;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAgC,EAChC,UAAA,GAAgDA,2DAA6B,EAC7E,WAAoB,EAAA;AAEpB,IAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK;IAC5B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY;AAAE,QAAA,OAAO,KAAK;AACrE,IAAA,IAAI;AACF,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE;AAC1B,YAAA,OAAOC,mCAAiB,CACtB,IAAI,EACJ,KAAK,CAAC,MAAM,EACZ,UAAU,EACV,SAAS,EACT,WAAW,CACZ;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY,EAAE;AAChC,YAAA,OAAOC,yDAA4B,CACjC,IAAI,EACJ,KAAK,CAAC,WAAW,EACjB,UAAU,EACVC,2DAA6B,CAAC,UAAU,CAAC,CAC1C;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO,EAAE;AAC3B,YAAA,QACEC,2CAAqB,CACnB,KAAK,CAAC,QAAQ,EACdC,mCAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,EACnCF,2DAA6B,CAAC,UAAU,CAAC,CAC1C;AACD,gBAAA,KAAK,CAAC,IAAI;qBACPG,uCAAmB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAIC,uCAAmB,CAAC;QAEpE;QACA,QACE,KAAK,CAAC,IAAI;aACTC,qCAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAID,uCAAmB,CAAC;IAEjE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/lib/core/transform/watch/watchInputEvidenceMatchesDisk.mjs

@@ -18,7 +18,10 @@ import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
  * a graph input by its state hash and physical target; a host input by the host
  * bytes' hash. The root-file membership is a walk over many paths and never
  * stands for one, so its evidence matches nothing here; the record holds it
- * apart. Evidence without a state proves nothing and does not match.
+ * apart. Evidence without a state proves nothing and does not match. A plugin
+ * tree is proven through the plugin cache records of the project the caller
+ * names, so a new process does not read its sources and SDK again
+ * (samchon/ttsc#1725).
  *
  * @evidence contracts/common.md#principled-implementation Each codec replays its recorded meaning: complete predicates, graph hash plus physical target, raw host hash or plugin-tree state; membership and absent state cannot establish one-path agreement.
  * @evidence contracts/common.md#clear-and-simple-design Discriminant branches delegate each observation to the codec owner and expose one conservative boolean comparison.
@@ -29,13 +32,13 @@ import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work This asks whether current disk observations match a record; observer and plugin-tree owners establish any valid reuse, rather than caching this boolean without change witnesses.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Comparison contexts and observed buffers are call-local; retained tree caches and active watchers have separate owners.
  */
-function watchInputEvidenceMatchesDisk(file, evidence, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+function watchInputEvidenceMatchesDisk(file, evidence, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, projectRoot) {
     const state = evidence.state;
     if (state === undefined || state.codec === "membership")
         return false;
     try {
         if (state.codec === "tree") {
-            return pluginSourceHolds(file, state.digest, filesystem);
+            return pluginSourceHolds(file, state.digest, filesystem, undefined, projectRoot);
         }
         if (state.codec === "predicates") {
             return matchesGraphInputObservation(file, state.observation, filesystem, createHostPathIdentityContext(filesystem));

package/lib/core/transform/watch/watchInputEvidenceMatchesDisk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"watchInputEvidenceMatchesDisk.mjs","sources":["../../../../src/core/transform/watch/watchInputEvidenceMatchesDisk.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAgC,EAChC,aAAgD,6BAA6B,EAAA;AAE7E,IAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK;IAC5B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY;AAAE,QAAA,OAAO,KAAK;AACrE,IAAA,IAAI;AACF,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE;YAC1B,OAAO,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC;QAC1D;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY,EAAE;AAChC,YAAA,OAAO,4BAA4B,CACjC,IAAI,EACJ,KAAK,CAAC,WAAW,EACjB,UAAU,EACV,6BAA6B,CAAC,UAAU,CAAC,CAC1C;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO,EAAE;AAC3B,YAAA,QACE,qBAAqB,CACnB,KAAK,CAAC,QAAQ,EACd,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,EACnC,6BAA6B,CAAC,UAAU,CAAC,CAC1C;AACD,gBAAA,KAAK,CAAC,IAAI;qBACP,mBAAmB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB,CAAC;QAEpE;QACA,QACE,KAAK,CAAC,IAAI;aACT,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB,CAAC;IAEjE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}
+{"version":3,"file":"watchInputEvidenceMatchesDisk.mjs","sources":["../../../../src/core/transform/watch/watchInputEvidenceMatchesDisk.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG,SAAU,6BAA6B,CAC3C,IAAY,EACZ,QAAgC,EAChC,UAAA,GAAgD,6BAA6B,EAC7E,WAAoB,EAAA;AAEpB,IAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK;IAC5B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY;AAAE,QAAA,OAAO,KAAK;AACrE,IAAA,IAAI;AACF,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE;AAC1B,YAAA,OAAO,iBAAiB,CACtB,IAAI,EACJ,KAAK,CAAC,MAAM,EACZ,UAAU,EACV,SAAS,EACT,WAAW,CACZ;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,YAAY,EAAE;AAChC,YAAA,OAAO,4BAA4B,CACjC,IAAI,EACJ,KAAK,CAAC,WAAW,EACjB,UAAU,EACV,6BAA6B,CAAC,UAAU,CAAC,CAC1C;QACH;AACA,QAAA,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO,EAAE;AAC3B,YAAA,QACE,qBAAqB,CACnB,KAAK,CAAC,QAAQ,EACd,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,EACnC,6BAA6B,CAAC,UAAU,CAAC,CAC1C;AACD,gBAAA,KAAK,CAAC,IAAI;qBACP,mBAAmB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB,CAAC;QAEpE;QACA,QACE,KAAK,CAAC,IAAI;aACT,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,mBAAmB,CAAC;IAEjE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/lib/core/turbopack/turbopack.js

@@ -164,6 +164,7 @@ function turbopack(source) {
     }
     const hooks = {
         exactPath: true,
+        watching,
         ...(addDependency === undefined
             ? {}
             : {
@@ -178,7 +179,7 @@ function turbopack(source) {
                     toolDirectory,
                     // Turbopack takes no record outside its root, so a watching worker
                     // refuses a module it could hand none (samchon/ttsc#1480).
-                    watching: bridge !== undefined,
+                    watching,
                 },
             }),
         ...(bindings.markVolatile === undefined

package/lib/core/turbopack/turbopack.js.map

@@ -1 +1 @@
-{"version":3,"file":"turbopack.js","sources":["../../../src/core/turbopack/turbopack.ts"],"sourcesContent":[null],"names":["createTtscTransformCache","shareTtscTransformCache","readTtscTransformSession","isTransformTarget","createTurbopackLoaderBindings","hostToolDirectory","openHostWatchBridge","refreshProjectRecordFiles","registerProjectRecord","transformTtsc","resolveOptions","TtscCompileFailureError","failedModuleSource"],"mappings":"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"}
+{"version":3,"file":"turbopack.js","sources":["../../../src/core/turbopack/turbopack.ts"],"sourcesContent":[null],"names":["createTtscTransformCache","shareTtscTransformCache","readTtscTransformSession","isTransformTarget","createTurbopackLoaderBindings","hostToolDirectory","openHostWatchBridge","refreshProjectRecordFiles","registerProjectRecord","transformTtsc","resolveOptions","TtscCompileFailureError","failedModuleSource"],"mappings":"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"}

package/lib/core/turbopack/turbopack.mjs

@@ -162,6 +162,7 @@ function turbopack(source) {
     }
     const hooks = {
         exactPath: true,
+        watching,
         ...(addDependency === undefined
             ? {}
             : {
@@ -176,7 +177,7 @@ function turbopack(source) {
                     toolDirectory,
                     // Turbopack takes no record outside its root, so a watching worker
                     // refuses a module it could hand none (samchon/ttsc#1480).
-                    watching: bridge !== undefined,
+                    watching,
                 },
             }),
         ...(bindings.markVolatile === undefined

package/lib/core/turbopack/turbopack.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"turbopack.mjs","sources":["../../../src/core/turbopack/turbopack.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;AAkBA;;;;;;;;AAQG;AACH,MAAM,cAAc,GAAG,wBAAwB,EAAE;AACjD,uBAAuB,CAAC,cAAc,EAAE,wBAAwB,EAAE,CAAC;AAEnE;;;;AAIG;AACH,IAAI,MAAmC;AAEvC;;;AAGG;AACH,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEG;AACG,SAAU,SAAS,CAEvB,MAAc,EAAA;AAEd,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,EAAE;;;AAG7B,IAAA,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY;;;;;;AAM9B,IAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;AAC5B,QAAA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B;IACF;;;;;;;;;;;;;;;;;;;AAmBA,IAAA,MAAM,QAAQ,GAAG,6BAA6B,CAAC,IAAI,CAAC;AACpD,IAAA,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,QAAQ;IAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;IACtD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,EAAE;AACrD,IAAA,MAAM,aAAa,GAAG,iBAAiB,CAAC,WAAW,CAAC;AACpD,IAAA,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,EAAE;;;;;;;;;;AAU5C,IAAA,IAAI,eAAmC;AACvC,IAAA,IAAI,QAAQ,IAAI,aAAa,KAAK,SAAS,EAAE;AAC3C,QAAA,IAAI,MAAM,KAAK,SAAS,EAAE;AACxB,YAAA,MAAM,GAAG,mBAAmB,CAAC,WAAW,CAAC;AACzC,YAAA,yBAAyB,CAAC,aAAa,EAAE,MAAM,CAAC;QAClD;AACA,QAAA,eAAe,GAAG,MAAM,CAAC,KAAK,EAAE;IAClC;SAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;AACxC,QAAA,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC;QAC5B,yBAAyB,CAAC,aAAa,CAAC;IAC1C;AACA,IAAA,MAAM,KAAK,GAAuB;AAChC,QAAA,SAAS,EAAE,IAAI;QACf,IAAI,aAAa,KAAK;AACpB,cAAE;AACF,cAAE;AACE,gBAAA,OAAO,EAAE;AACP,oBAAA,QAAQ,EAAE,CAAC,YAAqC,KAC9C,qBAAqB,CAAC;AACpB,wBAAA,YAAY,EAAE,aAAa;AAC3B,wBAAA,IAAI,MAAM,KAAK,SAAS,IAAI,eAAe,KAAK;AAC9C,8BAAE,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE;8BAC1D,EAAE,CAAC;wBACP,YAAY;qBACb,CAAC;oBACJ,aAAa;;;oBAGb,QAAQ,EAAE,MAAM,KAAK,SAAS;AAC/B,iBAAA;aACF,CAAC;AACN,QAAA,IAAI,QAAQ,CAAC,YAAY,KAAK;AAC5B,cAAE;cACA,EAAE,YAAY,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC;KAC7C;AACD,IAAA,aAAa,CACX,IAAI,EACJ,MAAM,EACN,cAAc,CAAC,aAAa,CAAC,EAC7B,SAAS,EACT,cAAc,EACd,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,GAAG,SAAS,GAAG,KAAK,CACpD,CAAC,IAAI,CACJ,CAAC,MAAM,KACL,MAAM,KAAK;AACT,UAAE,QAAQ,CAAC,SAAS,EAAE,MAAM;AAC5B,UAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAClD,CAAC,KAAK,KAAI;;;;;;;;;;;;;;;;;AAiBR,QAAA,IACE,CAAC,QAAQ;AACT,YAAA,SAAS,KAAK,SAAS;AACvB,YAAA,EAAE,KAAK,YAAY,uBAAuB,CAAC,EAC3C;YACA,QAAQ,CAAC,KAAK,CAAC;YACf;QACF;QACA,SAAS,CAAC,KAAK,CAAC;QAChB,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;AAChD,IAAA,CAAC,CACF;AACH;;;;"}
+{"version":3,"file":"turbopack.mjs","sources":["../../../src/core/turbopack/turbopack.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/unplugin",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "description": "Bundler adapters for ttsc plugins.",
   "main": "lib/index.js",
   "module": "lib/index.mjs",
@@ -202,7 +202,7 @@
     "fsevents": "^2.3.3"
   },
   "peerDependencies": {
-    "ttsc": "^0.31.0"
+    "ttsc": "^0.31.2"
   },
   "devDependencies": {
     "@wrtnlabs/evidence": "^0.3.1",
@@ -217,7 +217,7 @@
     "tslib": "^2.8.1",
     "typescript": "^7.0.2",
     "vite": "^7.3.5",
-    "ttsc": "0.31.0"
+    "ttsc": "0.31.2"
   },
   "repository": {
     "type": "git",

package/src/core/bridge/projectRecordMoved.ts

@@ -61,7 +61,9 @@ export function projectRecordMoved(
   refreshProcessClockReference(record.root, filesystem);
   for (const [input, evidence] of Object.entries(record.inputs)) {
     if (evidence === null || typeof evidence !== "object") return input;
-    if (!watchInputEvidenceMatchesDisk(input, evidence, filesystem))
+    if (
+      !watchInputEvidenceMatchesDisk(input, evidence, filesystem, record.root)
+    )
       return input;
   }
   if (record.membership === null) return undefined;

package/src/core/bun/bun.ts

@@ -8,7 +8,6 @@ import { typescriptTransformBunLoader } from "../source/typescriptTransformBunLo
 import { beginTtscTransformBuild } from "../transform/cache/beginTtscTransformBuild";
 import { createTtscTransformCache } from "../transform/cache/createTtscTransformCache";
 import { resetTtscTransformCache } from "../transform/cache/resetTtscTransformCache";
-import { withdrawTtscTransformGenerations } from "../transform/cache/withdrawTtscTransformGenerations";
 import { transformTtsc } from "../transform/transformTtsc";
 import { inlineSourceMap } from "../transform/utils/inlineSourceMap";
 import type { BunLikeBuild } from "./BunLikeBuild";
@@ -74,8 +73,9 @@ function resolveBunOptions(
  *   The first included transformable load resolves options once. One cache shares a validated
  *   project generation across deliveries; bundler start/end boundaries reset
  *   delivery proof, while a runtime retains its immutable module-load session.
- *   An incomplete observation withdraws the adapter's entire generation cache;
- *   only the newly compiled delivery is returned within this nonwatching session.
+ *   Coherent local output with unavailable observation shares first deliveries
+ *   only inside this nonwatching pass through the common proof owner; no
+ *   persistent host cache or shared publication can retain it.
  *   Setup snapshots the in-memory key population; changing host files/options
  *   is not authorized merely by an unchanged path or previously quiet callback.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
@@ -141,7 +141,11 @@ export function bun(options?: TtscBunOptions): BunLikePlugin {
               // The path this loader just read from disk is the file's own.
               exactPath: true,
               watching: false,
-              markVolatile: () => withdrawTtscTransformGenerations(cache),
+              // Bun has no reusable host module cache inside this immutable
+              // build/runtime session. The common core owns generation eviction
+              // and pass-only reuse; withdrawing it here recompiles every module
+              // when Bun cannot supply synchronous observation (#1712, #1713).
+              markVolatile: () => {},
             },
           );
           if (result !== undefined) {

package/src/core/observer/createInputObserver.ts

@@ -217,11 +217,12 @@ export function createInputObserver(
   let poller: { close(): void } | undefined;
   let flushTimer: NodeJS.Timeout | undefined;
 
-  // Windows and macOS run every native observer in the isolated watch broker:
-  // Windows so an abort in Node's fs-event backend cannot take the host process
-  // down with it (samchon/ttsc#1411), and macOS so each scope is its own
-  // FSEventStream, whose dropped events are reported instead of lost
-  // (samchon/ttsc#1418, samchon/ttsc#1425).
+  // Windows uses ttsc's native completion-port helper, excluding access-only
+  // notifications without opening Node fs-event handles (samchon/ttsc#1719).
+  // Do not restore fs.watch here: reads can invalidate an unchanged generation,
+  // and deleting a watched temporary tree can abort Node (samchon/ttsc#1411).
+  // macOS keeps each scope in its own brokered FSEventStream, whose dropped
+  // events are reported instead of lost (samchon/ttsc#1418, samchon/ttsc#1425).
   const open =
     operations.watch ??
     (process.platform === "win32" || process.platform === "darwin"
@@ -531,6 +532,8 @@ export function createInputObserver(
             entry.file,
             state.digest,
             DEFAULT_FILESYSTEM_OPERATIONS,
+            undefined,
+            projectRoot,
           );
         } else if (state?.codec === "predicates") {
           changed =

package/src/core/observer/openIsolatedRecursiveWatch.ts

@@ -7,18 +7,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/src/core/transform/cache/TtscCachedProjectTransform.ts

@@ -232,12 +232,22 @@ export interface TtscCachedProjectTransform {
 
   /**
    * 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/src/core/transform/cache/selectCachedGenerationAction.ts

@@ -1,5 +1,6 @@
 import { envelopeDerivation } from "../envelope/envelopeDerivation";
 import { isVolatileFile } from "../envelope/isVolatileFile";
+import type { TtscGenerationProof } from "../validation/TtscGenerationProof";
 import { matchesCachedSource } from "../validation/matchesCachedSource";
 import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
 import type { TtscTransformCache } from "./TtscTransformCache";
@@ -42,6 +43,7 @@ export function selectCachedGenerationAction(props: {
   generation: Promise<TtscCachedProjectTransform>;
   key: string;
   source: string;
+  proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture" {
   if (
     !isVolatileFile(envelopeDerivation(props.cached), {
@@ -49,7 +51,13 @@ export 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";
   }

package/src/core/transform/deliverCachedTransform.ts

@@ -0,0 +1,97 @@
+import type { TtscCachedProjectTransform } from "./cache/TtscCachedProjectTransform";
+import type { TtscTransformCache } from "./cache/TtscTransformCache";
+import { evictGeneration } from "./cache/evictGeneration";
+import { selectOrEvict } from "./cache/selectOrEvict";
+import { reportMissingProgramOutput } from "./diagnostics/reportMissingProgramOutput";
+import { reportSuccessDiagnostics } from "./diagnostics/reportSuccessDiagnostics";
+import { TtscMissingProgramOutputError } from "./errors/TtscMissingProgramOutputError";
+import { createTransformResult } from "./utils/createTransformResult";
+import { TtscGenerationProof } from "./validation/TtscGenerationProof";
+import { markCachedSourceServed } from "./validation/markCachedSourceServed";
+import type { TtscTransformHooks } from "./watch/TtscTransformHooks";
+import type { TtscWatchSelection } from "./watch/TtscWatchSelection";
+import { notifyFailedGenerationInputs } from "./watch/notifyFailedGenerationInputs";
+import { notifyVolatileDelivery } from "./watch/notifyVolatileDelivery";
+import { notifyWatchInputs } from "./watch/notifyWatchInputs";
+
+/**
+ * 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 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;
+}) {
+  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;
+  }
+}

package/src/core/transform/envelope/selectDeclaredProjectInputKeys.ts

@@ -26,8 +26,8 @@ import { isTransformScratchInput } from "../tsconfig/isTransformScratchInput";
  *   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
@@ -49,9 +49,12 @@ export function selectDeclaredProjectInputKeys(props: {
   }
   const graph = props.result.graph;
   const keys = new Set<string>();
+  const seen = new Set<string>();
   const add = (entry: unknown): void => {
     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(absolute, props.scratchDirectory)) return;
     const key = toProjectKey(props.projectRoot, absolute, props.identities);
     if (Object.prototype.hasOwnProperty.call(props.projectInputHashes, key)) {

package/src/core/transform/envelope/selectExternalInputPaths.ts

@@ -36,17 +36,15 @@ import { envelopeGraphIndexes } from "./envelopeGraphIndexes";
  * @evidence contracts/performance.md#efficient-algorithms
  *   Cold graph index construction precedes separate scans of output, graph,
  *   candidate, dependency and host lists, followed by every collected member's
- *   filter pass. Duplicate occurrences still pay path/identity and candidate
- *   observations before seen rejection; rejected walk members are not added to
- *   seen. Native path/ancestor/case, existence and walk policy/component checks
+ *   filter pass. Lexical deduplication precedes native identity/candidate/walk
+ *   observations, including rejected members; distinct aliases stay separate. Native path/ancestor/case, existence and walk policy/component checks
  *   add costs to list/key text. Collected members, candidate/seen sets and
  *   output allocate population-sized storage; final string sorting adds output
  *   comparison work.
  * @evidence contracts/performance.md#reuse-equivalent-work
  *   Generation state shares completed graph parsing, while this call's native
  *   identity context reuses its qualified path observations. The sets dedupe
- *   emitted lexical names and mark candidate membership; they do not suppress
- *   every repeated classification. Supplied filesystem, producer-derived state
+ *   every lexical classification and mark candidate membership. Supplied filesystem, producer-derived state
  *   and membership policy must represent the same stable generation view.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
  *   Its collections are local to the call and released on return; only the
@@ -144,6 +142,10 @@ export function selectExternalInputPaths(props: {
     }
     const absolute = path.resolve(props.projectRoot, member);
     const spelling = path.resolve(absolute);
+    // Classify each lexical address once, including rejected walk members.
+    // Physical aliases remain distinct so retargeting is still observable.
+    if (seen.has(spelling)) continue;
+    seen.add(spelling);
     const identity = pathIdentityKey(absolute, identities);
     const observation = graphIndexes.inputObservations.get(spelling);
     const missingCandidate =
@@ -153,7 +155,6 @@ export function selectExternalInputPaths(props: {
     if (
       identity === excluded ||
       isTransformScratchInput(absolute, props.scratchDirectory) ||
-      seen.has(spelling) ||
       (!missingCandidate &&
         isProjectWalkPath(
           props.projectRoot,
@@ -167,7 +168,6 @@ export function selectExternalInputPaths(props: {
     }
     // Preserve distinct lexical aliases even when they currently select the
     // same physical file. A later retarget must validate the alias itself.
-    seen.add(spelling);
     output.push(absolute);
   }
   output.sort();

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

@@ -198,23 +198,26 @@ export interface TtscTransformFilesystemOperations {
    * Open one directory's change notification, or throw when the observed
    * filesystem cannot provide one.
    *
-   * Left undefined, generations watch the host filesystem: in process on Linux,
-   * and through an isolated broker process on Windows and macOS. An embedder
-   * observing another filesystem supplies its own; a generation whose watch
-   * cannot be opened keeps validating from recorded state instead of losing its
-   * cache.
+   * Left undefined, generations watch the host filesystem through the native
+   * Linux helper, the native Windows completion-port helper, or the macOS
+   * FSEvents broker. An embedder observing another filesystem supplies its own;
+   * a generation whose watch cannot be opened keeps validating from recorded
+   * state instead of losing its cache.
    *
-   * Supplying one replaces the broker as well, so an embedder that wraps Node's
-   * own `fs.watch` gives up what the broker provides: on Windows, containing
-   * the native abort Node's fs-event backend can raise when a watched temporary
-   * tree is deleted, and on macOS, one FSEventStream per watch whose dropped
-   * events are reported rather than lost silently.
+   * Supplying one bypasses these native owners. Wrapping Node's `fs.watch`
+   * reintroduces Windows access-only notifications that invalidate unchanged
+   * inputs, and the native abort its fs-event backend can raise when a watched
+   * temporary tree is deleted. It also gives up explicit notification-loss
+   * reporting from the Linux helper and macOS's per-watch FSEventStream.
+   * Preserve mutation and loss reporting when implementing this capability;
+   * timestamps or identical current bytes cannot discard an actual A-B-A
+   * event.
    *
    * @evidence contracts/common.md#principled-implementation The watch capability reports actual directory changes and failure; its absence or failure cannot certify silence as unchanged inputs.
    * @evidence contracts/common.md#clear-and-simple-design One optional native operation exposes observation and a close handle, leaving broker selection and retained-generation proof in their owners.
    * @evidence contracts/common.md#prohibited-implementation-shortcuts Injected watches are explicit capabilities rather than patched fs methods, and errors require recorded-state validation instead of synthetic live coverage.
-   * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain absent overrides, failed watches, broker bypass, and the Windows/macOS capability lost when wrapping fs.watch directly.
-   * @evidence contracts/portability.md#os-neutral-implementation OS-neutral watching requires the observed filesystem's capability and accounts for backend-specific abort isolation and dropped-stream reporting rather than assuming recursive notifications are interchangeable.
+   * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain default owners, failed watches, explicit override authority, access-only noise, native aborts and mutation/loss reporting that a direct fs.watch wrapper cannot supply.
+   * @evidence contracts/portability.md#os-neutral-implementation OS-neutral watching requires the observed filesystem's capability and accounts for native Windows mutation filtering and Linux/macOS loss reporting rather than assuming recursive notifications are interchangeable.
    * @evidenceExclude contracts/performance.md#efficient-algorithms
    *   Only the signature of watch is declared here; the cost belongs to its
    *   implementation.

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

@@ -70,6 +70,7 @@ export function captureFailedGenerationInputStates(
                       environment: PluginBuildEnvironmentReadings.cached(input),
                     }
                   : undefined,
+                cached.projectRoot,
               ) ?? MISSING_INPUT_STATE,
             tree: true,
           },

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

@@ -422,7 +422,12 @@ export async function captureTransformGeneration(props: {
     // Prepare native toolchain authority before post-compile admission. Its
     // cold subprocess and SDK reads stay off this host's event loop, and the
     // config/walk/notification checks below include that asynchronous window.
-    await preparePluginBuildEnvironments(result, props.filesystem);
+    await preparePluginBuildEnvironments(
+      result,
+      props.filesystem,
+      undefined,
+      projectRoot,
+    );
     const { membershipPolicy, casePolicyLearned } =
       selectReportedMembershipPolicy(primedPolicy, result);
     TRANSFORM_RESULT_MEMBERSHIP.set(result, {

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

@@ -150,8 +150,18 @@ function environmentChanged(
         : undefined;
       if (
         recorded.state === MISSING_INPUT_STATE
-          ? pluginSourceState(input, prepared) !== null
-          : !pluginSourceHolds(input, recorded.state, filesystem, prepared)
+          ? pluginSourceState(
+              input,
+              prepared,
+              validation.cached.projectRoot,
+            ) !== null
+          : !pluginSourceHolds(
+              input,
+              recorded.state,
+              filesystem,
+              prepared,
+              validation.cached.projectRoot,
+            )
       )
         return true;
       continue;

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

@@ -8,7 +8,9 @@ import { onlyLearnedCompileFacts } from "./onlyLearnedCompileFacts";
  * facts describe the capture; this policy performs no capture or native proof.
  *
  * Coherent results return first. A local, lossless host-observation refusal can
- * transfer one fresh success without reuse authority. Rejected attempts spend
+ * transfer an incomplete local success. TtscGenerationProof owns any sharing of
+ * its first module deliveries inside an explicit nonwatching pass; this policy
+ * grants no independent native or persistent proof. Rejected attempts spend
  * movement only when they neither refute a publication nor solely learn facts.
  * Two movements or four captures stop retrying, retaining a current diagnostic
  * rather than a terminal instability verdict when its config is not refuted.