@ttsc/unplugin 0.31.0 → 0.31.2

package/lib/core/transform/inputs/pluginSourceFilesDigest.d.cts

@@ -15,9 +15,15 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * historical-directory eviction or owner partition and can grow with distinct
  * directory spellings.
  *
- * @param directory The source directory.
+ * @param directory The source directory. WARNING (samchon/ttsc#1725): the map
+ *   below ends with the process, and every bundler worker or restart is a new
+ *   one, so each first proof read every plugin source byte again (0.35 s for
+ *   typia's Go module). A caller that names its project takes a miss's digest
+ *   from that project's plugin cache records, which the load that reported the
+ *   state wrote.
  * @param filesystem The operations whose clock reference the caller refreshed
  *   (`refreshFilesystemClockReference`), which decides separability.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed file cannot be read, as `pluginSourceDigest` does.
  * @evidence contracts/common.md#principled-implementation The build's exact file selector signs names and metadata around a fresh byte digest; matching separable signatures permit reuse only under the same native source-tree and refreshed-clock premises.
  * @evidence contracts/common.md#clear-and-simple-design This coordinator owns the directory digest entry while ttsc owns selection and byte hashing and inputMetadataEvidence owns stamp interpretation.
@@ -25,7 +31,7 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain population invalidation, before/after proof, fresh clock ordering, native-view assumptions and unbounded retained entries, with separated tags following documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral native source paths use Node resolution and ttsc's native selector; injected metadata must observe those paths. A different filesystem view or path dialect is not supported by the native enumeration/read calls here.
  * @evidence contracts/performance.md#efficient-algorithms Reuse still enumerates and stats F files; a miss performs two metadata walks and one O(B) byte digest. Selection sorts its population, and temporary storage follows the file list and largest file buffer.
- * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view.
+ * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view. A miss of a caller naming its project takes the digest the load recorded in that project's plugin cache, across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources DIGESTS is module-owned and retains one digest/signature per encountered key until failed stabilization deletes that key or the process ends; no historical-directory bound or explicit teardown currently exists.
  */
-export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations): string;
+export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations, projectRoot?: string): string;

package/lib/core/transform/inputs/pluginSourceFilesDigest.d.mts

@@ -15,9 +15,15 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * historical-directory eviction or owner partition and can grow with distinct
  * directory spellings.
  *
- * @param directory The source directory.
+ * @param directory The source directory. WARNING (samchon/ttsc#1725): the map
+ *   below ends with the process, and every bundler worker or restart is a new
+ *   one, so each first proof read every plugin source byte again (0.35 s for
+ *   typia's Go module). A caller that names its project takes a miss's digest
+ *   from that project's plugin cache records, which the load that reported the
+ *   state wrote.
  * @param filesystem The operations whose clock reference the caller refreshed
  *   (`refreshFilesystemClockReference`), which decides separability.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed file cannot be read, as `pluginSourceDigest` does.
  * @evidence contracts/common.md#principled-implementation The build's exact file selector signs names and metadata around a fresh byte digest; matching separable signatures permit reuse only under the same native source-tree and refreshed-clock premises.
  * @evidence contracts/common.md#clear-and-simple-design This coordinator owns the directory digest entry while ttsc owns selection and byte hashing and inputMetadataEvidence owns stamp interpretation.
@@ -25,7 +31,7 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain population invalidation, before/after proof, fresh clock ordering, native-view assumptions and unbounded retained entries, with separated tags following documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral native source paths use Node resolution and ttsc's native selector; injected metadata must observe those paths. A different filesystem view or path dialect is not supported by the native enumeration/read calls here.
  * @evidence contracts/performance.md#efficient-algorithms Reuse still enumerates and stats F files; a miss performs two metadata walks and one O(B) byte digest. Selection sorts its population, and temporary storage follows the file list and largest file buffer.
- * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view.
+ * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view. A miss of a caller naming its project takes the digest the load recorded in that project's plugin cache, across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources DIGESTS is module-owned and retains one digest/signature per encountered key until failed stabilization deletes that key or the process ends; no historical-directory bound or explicit teardown currently exists.
  */
-export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations): string;
+export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations, projectRoot?: string): string;

package/lib/core/transform/inputs/pluginSourceFilesDigest.d.ts

@@ -15,9 +15,15 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * historical-directory eviction or owner partition and can grow with distinct
  * directory spellings.
  *
- * @param directory The source directory.
+ * @param directory The source directory. WARNING (samchon/ttsc#1725): the map
+ *   below ends with the process, and every bundler worker or restart is a new
+ *   one, so each first proof read every plugin source byte again (0.35 s for
+ *   typia's Go module). A caller that names its project takes a miss's digest
+ *   from that project's plugin cache records, which the load that reported the
+ *   state wrote.
  * @param filesystem The operations whose clock reference the caller refreshed
  *   (`refreshFilesystemClockReference`), which decides separability.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed file cannot be read, as `pluginSourceDigest` does.
  * @evidence contracts/common.md#principled-implementation The build's exact file selector signs names and metadata around a fresh byte digest; matching separable signatures permit reuse only under the same native source-tree and refreshed-clock premises.
  * @evidence contracts/common.md#clear-and-simple-design This coordinator owns the directory digest entry while ttsc owns selection and byte hashing and inputMetadataEvidence owns stamp interpretation.
@@ -25,7 +31,7 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain population invalidation, before/after proof, fresh clock ordering, native-view assumptions and unbounded retained entries, with separated tags following documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral native source paths use Node resolution and ttsc's native selector; injected metadata must observe those paths. A different filesystem view or path dialect is not supported by the native enumeration/read calls here.
  * @evidence contracts/performance.md#efficient-algorithms Reuse still enumerates and stats F files; a miss performs two metadata walks and one O(B) byte digest. Selection sorts its population, and temporary storage follows the file list and largest file buffer.
- * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view.
+ * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view. A miss of a caller naming its project takes the digest the load recorded in that project's plugin cache, across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources DIGESTS is module-owned and retains one digest/signature per encountered key until failed stabilization deletes that key or the process ends; no historical-directory bound or explicit teardown currently exists.
  */
-export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations): string;
+export declare function pluginSourceFilesDigest(directory: string, filesystem?: TtscTransformFilesystemOperations, projectRoot?: string): string;

package/lib/core/transform/inputs/pluginSourceFilesDigest.js

@@ -21,9 +21,15 @@ var inputMetadataEvidence = require('./inputMetadataEvidence.js');
  * historical-directory eviction or owner partition and can grow with distinct
  * directory spellings.
  *
- * @param directory The source directory.
+ * @param directory The source directory. WARNING (samchon/ttsc#1725): the map
+ *   below ends with the process, and every bundler worker or restart is a new
+ *   one, so each first proof read every plugin source byte again (0.35 s for
+ *   typia's Go module). A caller that names its project takes a miss's digest
+ *   from that project's plugin cache records, which the load that reported the
+ *   state wrote.
  * @param filesystem The operations whose clock reference the caller refreshed
  *   (`refreshFilesystemClockReference`), which decides separability.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed file cannot be read, as `pluginSourceDigest` does.
  * @evidence contracts/common.md#principled-implementation The build's exact file selector signs names and metadata around a fresh byte digest; matching separable signatures permit reuse only under the same native source-tree and refreshed-clock premises.
  * @evidence contracts/common.md#clear-and-simple-design This coordinator owns the directory digest entry while ttsc owns selection and byte hashing and inputMetadataEvidence owns stamp interpretation.
@@ -31,10 +37,10 @@ var inputMetadataEvidence = require('./inputMetadataEvidence.js');
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain population invalidation, before/after proof, fresh clock ordering, native-view assumptions and unbounded retained entries, with separated tags following documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral native source paths use Node resolution and ttsc's native selector; injected metadata must observe those paths. A different filesystem view or path dialect is not supported by the native enumeration/read calls here.
  * @evidence contracts/performance.md#efficient-algorithms Reuse still enumerates and stats F files; a miss performs two metadata walks and one O(B) byte digest. Selection sorts its population, and temporary storage follows the file list and largest file buffer.
- * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view.
+ * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view. A miss of a caller naming its project takes the digest the load recorded in that project's plugin cache, across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources DIGESTS is module-owned and retains one digest/signature per encountered key until failed stabilization deletes that key or the process ends; no historical-directory bound or explicit teardown currently exists.
  */
-function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS) {
+function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, projectRoot) {
     const key = path.resolve(directory);
     /**
      * Supply this caller's metadata and clock view to the shared native selector.
@@ -48,7 +54,7 @@ function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPER
         known?.signature === before.signature) {
         return known.digest;
     }
-    const digest = pluginSource.pluginSourceDigest(key);
+    const digest = pluginSource.provenPluginSourceDigest(key, projectRoot);
     const after = pluginSource.pluginSourceFilesSignature(key, evidence);
     if (before !== undefined &&
         after !== undefined &&

package/lib/core/transform/inputs/pluginSourceFilesDigest.js.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceFilesDigest.js","sources":["../../../../src/core/transform/inputs/pluginSourceFilesDigest.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","inputMetadataEvidence","pluginSourceFilesSignature","pluginSourceDigest"],"mappings":";;;;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,uBAAuB,CACrC,SAAiB,EACjB,aAAgDA,2DAA6B,EAAA;IAE7E,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;AACnC;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAKC,2CAAqB,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1E,MAAM,MAAM,GAAGC,uCAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IAC9B,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,MAAM,CAAC,SAAS;AAChB,QAAA,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,EACrC;QACA,OAAO,KAAK,CAAC,MAAM;IACrB;AACA,IAAA,MAAM,MAAM,GAAGC,+BAAkB,CAAC,GAAG,CAAC;IACtC,MAAM,KAAK,GAAGD,uCAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvD,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,KAAK,KAAK,SAAS;AACnB,QAAA,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;QACpC,KAAK,CAAC,SAAS,EACf;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IAC1D;SAAO;AACL,QAAA,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;IACrB;AACA,IAAA,OAAO,MAAM;AACf;AAEA;;;AAGG;AACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiD;;;;"}
+{"version":3,"file":"pluginSourceFilesDigest.js","sources":["../../../../src/core/transform/inputs/pluginSourceFilesDigest.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","inputMetadataEvidence","pluginSourceFilesSignature","provenPluginSourceDigest"],"mappings":";;;;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACG,SAAU,uBAAuB,CACrC,SAAiB,EACjB,UAAA,GAAgDA,2DAA6B,EAC7E,WAAoB,EAAA;IAEpB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;AACnC;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAKC,2CAAqB,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1E,MAAM,MAAM,GAAGC,uCAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IAC9B,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,MAAM,CAAC,SAAS;AAChB,QAAA,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,EACrC;QACA,OAAO,KAAK,CAAC,MAAM;IACrB;IACA,MAAM,MAAM,GAAGC,qCAAwB,CAAC,GAAG,EAAE,WAAW,CAAC;IACzD,MAAM,KAAK,GAAGD,uCAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvD,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,KAAK,KAAK,SAAS;AACnB,QAAA,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;QACpC,KAAK,CAAC,SAAS,EACf;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IAC1D;SAAO;AACL,QAAA,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;IACrB;AACA,IAAA,OAAO,MAAM;AACf;AAEA;;;AAGG;AACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiD;;;;"}

package/lib/core/transform/inputs/pluginSourceFilesDigest.mjs

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { pluginSourceFilesSignature, pluginSourceDigest } from 'ttsc/plugin-source';
+import { pluginSourceFilesSignature, provenPluginSourceDigest } from 'ttsc/plugin-source';
 import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
 import { inputMetadataEvidence } from './inputMetadataEvidence.mjs';
 
@@ -19,9 +19,15 @@ import { inputMetadataEvidence } from './inputMetadataEvidence.mjs';
  * historical-directory eviction or owner partition and can grow with distinct
  * directory spellings.
  *
- * @param directory The source directory.
+ * @param directory The source directory. WARNING (samchon/ttsc#1725): the map
+ *   below ends with the process, and every bundler worker or restart is a new
+ *   one, so each first proof read every plugin source byte again (0.35 s for
+ *   typia's Go module). A caller that names its project takes a miss's digest
+ *   from that project's plugin cache records, which the load that reported the
+ *   state wrote.
  * @param filesystem The operations whose clock reference the caller refreshed
  *   (`refreshFilesystemClockReference`), which decides separability.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed file cannot be read, as `pluginSourceDigest` does.
  * @evidence contracts/common.md#principled-implementation The build's exact file selector signs names and metadata around a fresh byte digest; matching separable signatures permit reuse only under the same native source-tree and refreshed-clock premises.
  * @evidence contracts/common.md#clear-and-simple-design This coordinator owns the directory digest entry while ttsc owns selection and byte hashing and inputMetadataEvidence owns stamp interpretation.
@@ -29,10 +35,10 @@ import { inputMetadataEvidence } from './inputMetadataEvidence.mjs';
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain population invalidation, before/after proof, fresh clock ordering, native-view assumptions and unbounded retained entries, with separated tags following documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral native source paths use Node resolution and ttsc's native selector; injected metadata must observe those paths. A different filesystem view or path dialect is not supported by the native enumeration/read calls here.
  * @evidence contracts/performance.md#efficient-algorithms Reuse still enumerates and stats F files; a miss performs two metadata walks and one O(B) byte digest. Selection sorts its population, and temporary storage follows the file list and largest file buffer.
- * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view.
+ * @evidence contracts/performance.md#reuse-equivalent-work All calls share DIGESTS by resolved directory spelling; current separable metadata must match the signature recorded around the producer read. The key does not partition filesystem owners, so sharing assumes one native source view. A miss of a caller naming its project takes the digest the load recorded in that project's plugin cache, across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources DIGESTS is module-owned and retains one digest/signature per encountered key until failed stabilization deletes that key or the process ends; no historical-directory bound or explicit teardown currently exists.
  */
-function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, projectRoot) {
     const key = path.resolve(directory);
     /**
      * Supply this caller's metadata and clock view to the shared native selector.
@@ -46,7 +52,7 @@ function pluginSourceFilesDigest(directory, filesystem = DEFAULT_FILESYSTEM_OPER
         known?.signature === before.signature) {
         return known.digest;
     }
-    const digest = pluginSourceDigest(key);
+    const digest = provenPluginSourceDigest(key, projectRoot);
     const after = pluginSourceFilesSignature(key, evidence);
     if (before !== undefined &&
         after !== undefined &&

package/lib/core/transform/inputs/pluginSourceFilesDigest.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceFilesDigest.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceFilesDigest.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,uBAAuB,CACrC,SAAiB,EACjB,aAAgD,6BAA6B,EAAA;IAE7E,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;AACnC;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAK,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1E,MAAM,MAAM,GAAG,0BAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IAC9B,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,MAAM,CAAC,SAAS;AAChB,QAAA,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,EACrC;QACA,OAAO,KAAK,CAAC,MAAM;IACrB;AACA,IAAA,MAAM,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC;IACtC,MAAM,KAAK,GAAG,0BAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvD,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,KAAK,KAAK,SAAS;AACnB,QAAA,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;QACpC,KAAK,CAAC,SAAS,EACf;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IAC1D;SAAO;AACL,QAAA,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;IACrB;AACA,IAAA,OAAO,MAAM;AACf;AAEA;;;AAGG;AACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiD;;;;"}
+{"version":3,"file":"pluginSourceFilesDigest.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceFilesDigest.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACG,SAAU,uBAAuB,CACrC,SAAiB,EACjB,UAAA,GAAgD,6BAA6B,EAC7E,WAAoB,EAAA;IAEpB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;AACnC;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAG,CAAC,IAAY,KAAK,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1E,MAAM,MAAM,GAAG,0BAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IAC9B,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,MAAM,CAAC,SAAS;AAChB,QAAA,KAAK,EAAE,SAAS,KAAK,MAAM,CAAC,SAAS,EACrC;QACA,OAAO,KAAK,CAAC,MAAM;IACrB;IACA,MAAM,MAAM,GAAG,wBAAwB,CAAC,GAAG,EAAE,WAAW,CAAC;IACzD,MAAM,KAAK,GAAG,0BAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvD,IACE,MAAM,KAAK,SAAS;AACpB,QAAA,KAAK,KAAK,SAAS;AACnB,QAAA,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;QACpC,KAAK,CAAC,SAAS,EACf;AACA,QAAA,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IAC1D;SAAO;AACL,QAAA,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC;IACrB;AACA,IAAA,OAAO,MAAM;AACf;AAEA;;;AAGG;AACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiD;;;;"}

package/lib/core/transform/inputs/pluginSourceHolds.d.cts

@@ -21,15 +21,17 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @param state The state the envelope, a record, or a capture recorded.
  * @param filesystem The operations whose clock reference the caller refreshed.
  * @param prepared Optional already-qualified native environment authority.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Source-state equality uses ttsc's build-key composition. Synchronous clients retain mismatch-triggered environment refresh; async clients supply current native authority and own fresh preparation separately. Unavailable source or prepared environment rejects proof.
  * @evidence contracts/common.md#clear-and-simple-design This adapter supplies a proven source digest to the shared state comparator, keeping environment composition and refresh in ttsc's owner.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The fresh environment comparison corrects an actual stale environment witness; unreadable source is not hidden by expected state exceptions or perpetual compensating retries.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain source versus environment proof, failure semantics and refreshed-clock parameters, followed by separated tags under documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral source/environment comparison uses the build's native boundaries. Injected metadata must describe that same native source tree; arbitrary foreign-filesystem views are not established by this adapter.
  * @evidence contracts/performance.md#efficient-algorithms One proven source digest serves either the supplied-environment comparison or both synchronous environment comparisons; file work is delegated to the digest owner.
- * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths.
+ * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths. A named project lets the source and SDK readings come from its plugin cache records across processes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This comparison acquires no retained source cache or native handle; digest storage and process-environment retention have separate owners.
  */
 export declare function pluginSourceHolds(directory: string, state: string, filesystem?: TtscTransformFilesystemOperations, prepared?: {
     environment: string | undefined;
-}): boolean;
+}, projectRoot?: string): boolean;

package/lib/core/transform/inputs/pluginSourceHolds.d.mts

@@ -21,15 +21,17 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @param state The state the envelope, a record, or a capture recorded.
  * @param filesystem The operations whose clock reference the caller refreshed.
  * @param prepared Optional already-qualified native environment authority.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Source-state equality uses ttsc's build-key composition. Synchronous clients retain mismatch-triggered environment refresh; async clients supply current native authority and own fresh preparation separately. Unavailable source or prepared environment rejects proof.
  * @evidence contracts/common.md#clear-and-simple-design This adapter supplies a proven source digest to the shared state comparator, keeping environment composition and refresh in ttsc's owner.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The fresh environment comparison corrects an actual stale environment witness; unreadable source is not hidden by expected state exceptions or perpetual compensating retries.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain source versus environment proof, failure semantics and refreshed-clock parameters, followed by separated tags under documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral source/environment comparison uses the build's native boundaries. Injected metadata must describe that same native source tree; arbitrary foreign-filesystem views are not established by this adapter.
  * @evidence contracts/performance.md#efficient-algorithms One proven source digest serves either the supplied-environment comparison or both synchronous environment comparisons; file work is delegated to the digest owner.
- * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths.
+ * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths. A named project lets the source and SDK readings come from its plugin cache records across processes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This comparison acquires no retained source cache or native handle; digest storage and process-environment retention have separate owners.
  */
 export declare function pluginSourceHolds(directory: string, state: string, filesystem?: TtscTransformFilesystemOperations, prepared?: {
     environment: string | undefined;
-}): boolean;
+}, projectRoot?: string): boolean;

package/lib/core/transform/inputs/pluginSourceHolds.d.ts

@@ -21,15 +21,17 @@ import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransf
  * @param state The state the envelope, a record, or a capture recorded.
  * @param filesystem The operations whose clock reference the caller refreshed.
  * @param prepared Optional already-qualified native environment authority.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Source-state equality uses ttsc's build-key composition. Synchronous clients retain mismatch-triggered environment refresh; async clients supply current native authority and own fresh preparation separately. Unavailable source or prepared environment rejects proof.
  * @evidence contracts/common.md#clear-and-simple-design This adapter supplies a proven source digest to the shared state comparator, keeping environment composition and refresh in ttsc's owner.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The fresh environment comparison corrects an actual stale environment witness; unreadable source is not hidden by expected state exceptions or perpetual compensating retries.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain source versus environment proof, failure semantics and refreshed-clock parameters, followed by separated tags under documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral source/environment comparison uses the build's native boundaries. Injected metadata must describe that same native source tree; arbitrary foreign-filesystem views are not established by this adapter.
  * @evidence contracts/performance.md#efficient-algorithms One proven source digest serves either the supplied-environment comparison or both synchronous environment comparisons; file work is delegated to the digest owner.
- * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths.
+ * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths. A named project lets the source and SDK readings come from its plugin cache records across processes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This comparison acquires no retained source cache or native handle; digest storage and process-environment retention have separate owners.
  */
 export declare function pluginSourceHolds(directory: string, state: string, filesystem?: TtscTransformFilesystemOperations, prepared?: {
     environment: string | undefined;
-}): boolean;
+}, projectRoot?: string): boolean;

package/lib/core/transform/inputs/pluginSourceHolds.js

@@ -26,25 +26,30 @@ var pluginSourceFilesDigest = require('./pluginSourceFilesDigest.js');
  * @param state The state the envelope, a record, or a capture recorded.
  * @param filesystem The operations whose clock reference the caller refreshed.
  * @param prepared Optional already-qualified native environment authority.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Source-state equality uses ttsc's build-key composition. Synchronous clients retain mismatch-triggered environment refresh; async clients supply current native authority and own fresh preparation separately. Unavailable source or prepared environment rejects proof.
  * @evidence contracts/common.md#clear-and-simple-design This adapter supplies a proven source digest to the shared state comparator, keeping environment composition and refresh in ttsc's owner.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The fresh environment comparison corrects an actual stale environment witness; unreadable source is not hidden by expected state exceptions or perpetual compensating retries.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain source versus environment proof, failure semantics and refreshed-clock parameters, followed by separated tags under documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral source/environment comparison uses the build's native boundaries. Injected metadata must describe that same native source tree; arbitrary foreign-filesystem views are not established by this adapter.
  * @evidence contracts/performance.md#efficient-algorithms One proven source digest serves either the supplied-environment comparison or both synchronous environment comparisons; file work is delegated to the digest owner.
- * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths.
+ * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths. A named project lets the source and SDK readings come from its plugin cache records across processes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This comparison acquires no retained source cache or native handle; digest storage and process-environment retention have separate owners.
  */
-function pluginSourceHolds(directory, state, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, prepared) {
+function pluginSourceHolds(directory, state, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS, prepared, projectRoot) {
     try {
-        const sourceDigest = pluginSourceFilesDigest.pluginSourceFilesDigest(directory, filesystem);
+        const sourceDigest = pluginSourceFilesDigest.pluginSourceFilesDigest(directory, filesystem, projectRoot);
         if (prepared !== undefined)
             return (prepared.environment !== undefined &&
                 pluginSource.pluginSourceState(directory, {
                     environment: prepared.environment,
                     sourceDigest,
                 }) === state);
-        return pluginSource.pluginSourceStateHolds(directory, state, { sourceDigest });
+        return pluginSource.pluginSourceStateHolds(directory, state, {
+            projectRoot,
+            sourceDigest,
+        });
     }
     catch {
         return false;

package/lib/core/transform/inputs/pluginSourceHolds.js.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceHolds.js","sources":["../../../../src/core/transform/inputs/pluginSourceHolds.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","pluginSourceFilesDigest","pluginSourceState","pluginSourceStateHolds"],"mappings":";;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAA,GAAgDA,2DAA6B,EAC7E,QAA8C,EAAA;AAE9C,IAAA,IAAI;QACF,MAAM,YAAY,GAAGC,+CAAuB,CAAC,SAAS,EAAE,UAAU,CAAC;QACnE,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,QACE,QAAQ,CAAC,WAAW,KAAK,SAAS;gBAClCC,8BAAiB,CAAC,SAAS,EAAE;oBAC3B,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,YAAY;iBACb,CAAC,KAAK,KAAK;QAEhB,OAAOC,mCAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,YAAY,EAAE,CAAC;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}
+{"version":3,"file":"pluginSourceHolds.js","sources":["../../../../src/core/transform/inputs/pluginSourceHolds.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","pluginSourceFilesDigest","pluginSourceState","pluginSourceStateHolds"],"mappings":";;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAA,GAAgDA,2DAA6B,EAC7E,QAA8C,EAC9C,WAAoB,EAAA;AAEpB,IAAA,IAAI;QACF,MAAM,YAAY,GAAGC,+CAAuB,CAC1C,SAAS,EACT,UAAU,EACV,WAAW,CACZ;QACD,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,QACE,QAAQ,CAAC,WAAW,KAAK,SAAS;gBAClCC,8BAAiB,CAAC,SAAS,EAAE;oBAC3B,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,YAAY;iBACb,CAAC,KAAK,KAAK;AAEhB,QAAA,OAAOC,mCAAsB,CAAC,SAAS,EAAE,KAAK,EAAE;YAC9C,WAAW;YACX,YAAY;AACb,SAAA,CAAC;IACJ;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/lib/core/transform/inputs/pluginSourceHolds.mjs

@@ -24,25 +24,30 @@ import { pluginSourceFilesDigest } from './pluginSourceFilesDigest.mjs';
  * @param state The state the envelope, a record, or a capture recorded.
  * @param filesystem The operations whose clock reference the caller refreshed.
  * @param prepared Optional already-qualified native environment authority.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Source-state equality uses ttsc's build-key composition. Synchronous clients retain mismatch-triggered environment refresh; async clients supply current native authority and own fresh preparation separately. Unavailable source or prepared environment rejects proof.
  * @evidence contracts/common.md#clear-and-simple-design This adapter supplies a proven source digest to the shared state comparator, keeping environment composition and refresh in ttsc's owner.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The fresh environment comparison corrects an actual stale environment witness; unreadable source is not hidden by expected state exceptions or perpetual compensating retries.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain source versus environment proof, failure semantics and refreshed-clock parameters, followed by separated tags under documentation guidance.
  * @evidence contracts/portability.md#os-neutral-implementation OS-neutral source/environment comparison uses the build's native boundaries. Injected metadata must describe that same native source tree; arbitrary foreign-filesystem views are not established by this adapter.
  * @evidence contracts/performance.md#efficient-algorithms One proven source digest serves either the supplied-environment comparison or both synchronous environment comparisons; file work is delegated to the digest owner.
- * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths.
+ * @evidence contracts/performance.md#reuse-equivalent-work Metadata-proven source digests and current native environment witnesses qualify reuse; async preparation and synchronous mismatch refresh remain distinct owning paths. A named project lets the source and SDK readings come from its plugin cache records across processes.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This comparison acquires no retained source cache or native handle; digest storage and process-environment retention have separate owners.
  */
-function pluginSourceHolds(directory, state, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, prepared) {
+function pluginSourceHolds(directory, state, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, prepared, projectRoot) {
     try {
-        const sourceDigest = pluginSourceFilesDigest(directory, filesystem);
+        const sourceDigest = pluginSourceFilesDigest(directory, filesystem, projectRoot);
         if (prepared !== undefined)
             return (prepared.environment !== undefined &&
                 pluginSourceState(directory, {
                     environment: prepared.environment,
                     sourceDigest,
                 }) === state);
-        return pluginSourceStateHolds(directory, state, { sourceDigest });
+        return pluginSourceStateHolds(directory, state, {
+            projectRoot,
+            sourceDigest,
+        });
     }
     catch {
         return false;

package/lib/core/transform/inputs/pluginSourceHolds.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceHolds.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceHolds.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAA,GAAgD,6BAA6B,EAC7E,QAA8C,EAAA;AAE9C,IAAA,IAAI;QACF,MAAM,YAAY,GAAG,uBAAuB,CAAC,SAAS,EAAE,UAAU,CAAC;QACnE,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,QACE,QAAQ,CAAC,WAAW,KAAK,SAAS;gBAClC,iBAAiB,CAAC,SAAS,EAAE;oBAC3B,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,YAAY;iBACb,CAAC,KAAK,KAAK;QAEhB,OAAO,sBAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,YAAY,EAAE,CAAC;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}
+{"version":3,"file":"pluginSourceHolds.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceHolds.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,KAAa,EACb,UAAA,GAAgD,6BAA6B,EAC7E,QAA8C,EAC9C,WAAoB,EAAA;AAEpB,IAAA,IAAI;QACF,MAAM,YAAY,GAAG,uBAAuB,CAC1C,SAAS,EACT,UAAU,EACV,WAAW,CACZ;QACD,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,QACE,QAAQ,CAAC,WAAW,KAAK,SAAS;gBAClC,iBAAiB,CAAC,SAAS,EAAE;oBAC3B,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,YAAY;iBACb,CAAC,KAAK,KAAK;AAEhB,QAAA,OAAO,sBAAsB,CAAC,SAAS,EAAE,KAAK,EAAE;YAC9C,WAAW;YACX,YAAY;AACb,SAAA,CAAC;IACJ;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/lib/core/transform/inputs/pluginSourceState.d.cts

@@ -19,6 +19,8 @@
  *
  * @param directory The source directory, as the envelope names it.
  * @param prepared Optional current environment prepared by the async owner.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation The shared pluginSourceState composition combines source digest and build environment exactly as binary keys do, and an observation error preserves null rather than a plausible state.
  * @evidence contracts/common.md#clear-and-simple-design Capture delegates state composition to ttsc while proof callers use pluginSourceHolds for mismatch refresh; the two roles are explicit without duplicate key logic.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations cannot become hardcoded state or equal a recorded valid state through an exception branch.
@@ -30,4 +32,4 @@
  */
 export declare function pluginSourceState(directory: string, prepared?: {
     environment: string | undefined;
-}): string | null;
+}, projectRoot?: string): string | null;

package/lib/core/transform/inputs/pluginSourceState.d.mts

@@ -19,6 +19,8 @@
  *
  * @param directory The source directory, as the envelope names it.
  * @param prepared Optional current environment prepared by the async owner.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation The shared pluginSourceState composition combines source digest and build environment exactly as binary keys do, and an observation error preserves null rather than a plausible state.
  * @evidence contracts/common.md#clear-and-simple-design Capture delegates state composition to ttsc while proof callers use pluginSourceHolds for mismatch refresh; the two roles are explicit without duplicate key logic.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations cannot become hardcoded state or equal a recorded valid state through an exception branch.
@@ -30,4 +32,4 @@
  */
 export declare function pluginSourceState(directory: string, prepared?: {
     environment: string | undefined;
-}): string | null;
+}, projectRoot?: string): string | null;

package/lib/core/transform/inputs/pluginSourceState.d.ts

@@ -19,6 +19,8 @@
  *
  * @param directory The source directory, as the envelope names it.
  * @param prepared Optional current environment prepared by the async owner.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation The shared pluginSourceState composition combines source digest and build environment exactly as binary keys do, and an observation error preserves null rather than a plausible state.
  * @evidence contracts/common.md#clear-and-simple-design Capture delegates state composition to ttsc while proof callers use pluginSourceHolds for mismatch refresh; the two roles are explicit without duplicate key logic.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations cannot become hardcoded state or equal a recorded valid state through an exception branch.
@@ -30,4 +32,4 @@
  */
 export declare function pluginSourceState(directory: string, prepared?: {
     environment: string | undefined;
-}): string | null;
+}, projectRoot?: string): string | null;

package/lib/core/transform/inputs/pluginSourceState.js

@@ -42,6 +42,8 @@ var pluginSource__namespace = /*#__PURE__*/_interopNamespaceDefault(pluginSource
  *
  * @param directory The source directory, as the envelope names it.
  * @param prepared Optional current environment prepared by the async owner.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation The shared pluginSourceState composition combines source digest and build environment exactly as binary keys do, and an observation error preserves null rather than a plausible state.
  * @evidence contracts/common.md#clear-and-simple-design Capture delegates state composition to ttsc while proof callers use pluginSourceHolds for mismatch refresh; the two roles are explicit without duplicate key logic.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations cannot become hardcoded state or equal a recorded valid state through an exception branch.
@@ -51,13 +53,16 @@ var pluginSource__namespace = /*#__PURE__*/_interopNamespaceDefault(pluginSource
  * @evidenceExclude contracts/performance.md#efficient-algorithms The digest and its cost belong to ttsc's pluginSourceState; this wrapper only turns a failure into null.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work This observation adapter adds no sharing. The shared state owner reads source bytes for each call and can reuse qualified process-environment readings; a supplied environment remains the caller's current authority rather than a source-digest cache.
  */
-function pluginSourceState(directory, prepared) {
+function pluginSourceState(directory, prepared, projectRoot) {
     try {
         if (prepared !== undefined)
             return prepared.environment === undefined
                 ? null
-                : pluginSource__namespace.pluginSourceState(directory, prepared);
-        return pluginSource__namespace.pluginSourceState(directory);
+                : pluginSource__namespace.pluginSourceState(directory, {
+                    environment: prepared.environment,
+                    projectRoot,
+                });
+        return pluginSource__namespace.pluginSourceState(directory, { projectRoot });
     }
     catch {
         return null;

package/lib/core/transform/inputs/pluginSourceState.js.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceState.js","sources":["../../../../src/core/transform/inputs/pluginSourceState.ts"],"sourcesContent":[null],"names":["pluginSource"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,QAA8C,EAAA;AAE9C,IAAA,IAAI;QACF,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,OAAO,QAAQ,CAAC,WAAW,KAAK;AAC9B,kBAAE;kBACAA,uBAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC;AACzD,QAAA,OAAOA,uBAAY,CAAC,iBAAiB,CAAC,SAAS,CAAC;IAClD;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,IAAI;IACb;AACF;;;;"}
+{"version":3,"file":"pluginSourceState.js","sources":["../../../../src/core/transform/inputs/pluginSourceState.ts"],"sourcesContent":[null],"names":["pluginSource"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;SACa,iBAAiB,CAC/B,SAAiB,EACjB,QAA8C,EAC9C,WAAoB,EAAA;AAEpB,IAAA,IAAI;QACF,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,OAAO,QAAQ,CAAC,WAAW,KAAK;AAC9B,kBAAE;AACF,kBAAEA,uBAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE;oBACxC,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,WAAW;AACZ,iBAAA,CAAC;QACR,OAAOA,uBAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,CAAC;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,IAAI;IACb;AACF;;;;"}

package/lib/core/transform/inputs/pluginSourceState.mjs

@@ -21,6 +21,8 @@ import * as pluginSource from 'ttsc/plugin-source';
  *
  * @param directory The source directory, as the envelope names it.
  * @param prepared Optional current environment prepared by the async owner.
+ * @param projectRoot Project whose plugin cache records prove the sources and
+ *   the SDK in a new process (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation The shared pluginSourceState composition combines source digest and build environment exactly as binary keys do, and an observation error preserves null rather than a plausible state.
  * @evidence contracts/common.md#clear-and-simple-design Capture delegates state composition to ttsc while proof callers use pluginSourceHolds for mismatch refresh; the two roles are explicit without duplicate key logic.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations cannot become hardcoded state or equal a recorded valid state through an exception branch.
@@ -30,13 +32,16 @@ import * as pluginSource from 'ttsc/plugin-source';
  * @evidenceExclude contracts/performance.md#efficient-algorithms The digest and its cost belong to ttsc's pluginSourceState; this wrapper only turns a failure into null.
  * @evidenceExclude contracts/performance.md#reuse-equivalent-work This observation adapter adds no sharing. The shared state owner reads source bytes for each call and can reuse qualified process-environment readings; a supplied environment remains the caller's current authority rather than a source-digest cache.
  */
-function pluginSourceState(directory, prepared) {
+function pluginSourceState(directory, prepared, projectRoot) {
     try {
         if (prepared !== undefined)
             return prepared.environment === undefined
                 ? null
-                : pluginSource.pluginSourceState(directory, prepared);
-        return pluginSource.pluginSourceState(directory);
+                : pluginSource.pluginSourceState(directory, {
+                    environment: prepared.environment,
+                    projectRoot,
+                });
+        return pluginSource.pluginSourceState(directory, { projectRoot });
     }
     catch {
         return null;

package/lib/core/transform/inputs/pluginSourceState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pluginSourceState.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceState.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACG,SAAU,iBAAiB,CAC/B,SAAiB,EACjB,QAA8C,EAAA;AAE9C,IAAA,IAAI;QACF,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,OAAO,QAAQ,CAAC,WAAW,KAAK;AAC9B,kBAAE;kBACA,YAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC;AACzD,QAAA,OAAO,YAAY,CAAC,iBAAiB,CAAC,SAAS,CAAC;IAClD;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,IAAI;IACb;AACF;;;;"}
+{"version":3,"file":"pluginSourceState.mjs","sources":["../../../../src/core/transform/inputs/pluginSourceState.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;SACa,iBAAiB,CAC/B,SAAiB,EACjB,QAA8C,EAC9C,WAAoB,EAAA;AAEpB,IAAA,IAAI;QACF,IAAI,QAAQ,KAAK,SAAS;AACxB,YAAA,OAAO,QAAQ,CAAC,WAAW,KAAK;AAC9B,kBAAE;AACF,kBAAE,YAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE;oBACxC,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,WAAW;AACZ,iBAAA,CAAC;QACR,OAAO,YAAY,CAAC,iBAAiB,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,CAAC;IACnE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,IAAI;IACb;AACF;;;;"}

package/lib/core/transform/inputs/preparePluginBuildEnvironments.d.cts

@@ -1,27 +1,40 @@
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
 import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
 /**
- * Prepare actual plugin toolchain authority before synchronous input proofs.
+ * Qualify actual plugin toolchain authority before synchronous input proofs.
  * Cold Go/environment/SDK work stays off the host thread. A mismatch requests
  * one fresh native environment reading; observation failure remains unavailable
  * and the following admission or replay validator retains its failure policy. A
  * resident generation can reuse its exact proven source state while healthy
  * notifications and the still-qualified environment witness both hold. Native
- * environment preparation remains mandatory; source events cannot prove it.
+ * environment authority remains mandatory; source events cannot prove it.
+ *
+ * WARNING (#1712): yield before observing queued source changes, then qualify
+ * all current readings in one synchronous batch. Missing readings require an
+ * await and a fresh batch afterward. Source comparisons may request native
+ * refreshes; the caller must establish another current proof after those
+ * awaits. Never preserve a positive batch across an await or replay the SDK
+ * witness independently for every plugin and nested validator.
+ *
+ * The project root reaches ttsc's environment worker, so that isolate proves
+ * the Go SDK and executables from the plugin cache's records instead of reading
+ * 135 MB of SDK once per bundler or runtime process (samchon/ttsc#1722).
  *
  * @param cached Optional resident generation whose existing source-state and
  *   environment witness may qualify source reuse. Other preparation owners
  *   retain direct source comparison.
- * @evidence contracts/common.md#principled-implementation Every reported plugin directory prepares its actual current environment. The same result's matching manifest state can share source proof only with a healthy exact-source tracker and the environment under which that tree was proven. Otherwise this operation compares source state once and a mismatch refreshes environment authority for the following owning validator to compare again; failed preparation cannot qualify an input.
+ * @param projectRoot Project whose plugin cache holds those records; the
+ *   resident generation's own root when omitted.
+ * @evidence contracts/common.md#principled-implementation Every reported plugin directory qualifies current environment authority; only missing readings require asynchronous preparation. The same result's matching manifest state can share source proof only with a healthy exact-source tracker and the environment under which that tree was proven. Otherwise this operation compares source state once and a mismatch refreshes environment authority for the following owning validator to compare again; failed preparation cannot qualify an input.
  * @evidence contracts/common.md#clear-and-simple-design One async boundary precedes existing synchronous generation, delivery and terminal proofs.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations stay unproved; reported binary state never substitutes for native environment preparation or source comparison.
  * @evidence contracts/common.md#meaningful-documentation Native prose identifies off-thread work, mismatch refresh and preserved downstream failure ownership.
  * @evidence contracts/portability.md#os-neutral-implementation The same native toolchain/environment reader and caller filesystem source digest qualify each directory without platform guesses.
- * @evidence contracts/performance.md#efficient-algorithms The envelope selector builds its directory map once per result, and preparation visits each reported directory once. Environment requests build keys from effective variables and qualify native dependencies. A qualified source witness avoids enumeration; other source comparisons enumerate and sort files, check metadata and hash bytes when the digest cannot be reused. A mismatch requests one environment refresh rather than a second source comparison here.
+ * @evidence contracts/performance.md#efficient-algorithms The envelope selector indexes directories once per result. Linear directory passes batch-qualify current readings, prepare missing authority, compare source state and refresh mismatches. Each synchronous batch hashes variables once and shares distinct native dependencies; any preparation await requires another current batch. A qualified source witness avoids enumeration; other source comparisons enumerate and sort files, check metadata and hash bytes when the digest cannot be reused. A mismatch requests one environment refresh rather than a second source comparison here.
  * @evidence contracts/performance.md#reuse-equivalent-work The environment owner shares equivalent in-flight requests and still-qualified readings. Resident source proof is reused only for the exact result and manifest digest, unchanged qualified environment and currently healthy covered source notifications; absent, dirty, replaced or unavailable witnesses retain direct proof. No epoch or quiet watcher alone authorizes reuse, and subsequent admission still owns its current validation.
  * @evidence contracts/performance.md#bound-retention-and-release-resources This module records asynchronous execution ownership in a WeakSet before preparation, including failures, so disposed results are not retained. Requests and worker lifetimes remain with the environment owner; this sequential operation awaits each request and acquires no native observer or independent cancellation handle.
  */
-export declare function preparePluginBuildEnvironments(result: TtscCachedProjectTransform["result"], filesystem: TtscTransformFilesystemOperations, cached?: TtscCachedProjectTransform): Promise<void>;
+export declare function preparePluginBuildEnvironments(result: TtscCachedProjectTransform["result"], filesystem: TtscTransformFilesystemOperations, cached?: TtscCachedProjectTransform, projectRoot?: string | undefined): Promise<void>;
 /**
  * Whether this result's owner attempted asynchronous native preparation. This
  * records execution ownership, never successful observation authority.

package/lib/core/transform/inputs/preparePluginBuildEnvironments.d.mts

@@ -1,27 +1,40 @@
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
 import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
 /**
- * Prepare actual plugin toolchain authority before synchronous input proofs.
+ * Qualify actual plugin toolchain authority before synchronous input proofs.
  * Cold Go/environment/SDK work stays off the host thread. A mismatch requests
  * one fresh native environment reading; observation failure remains unavailable
  * and the following admission or replay validator retains its failure policy. A
  * resident generation can reuse its exact proven source state while healthy
  * notifications and the still-qualified environment witness both hold. Native
- * environment preparation remains mandatory; source events cannot prove it.
+ * environment authority remains mandatory; source events cannot prove it.
+ *
+ * WARNING (#1712): yield before observing queued source changes, then qualify
+ * all current readings in one synchronous batch. Missing readings require an
+ * await and a fresh batch afterward. Source comparisons may request native
+ * refreshes; the caller must establish another current proof after those
+ * awaits. Never preserve a positive batch across an await or replay the SDK
+ * witness independently for every plugin and nested validator.
+ *
+ * The project root reaches ttsc's environment worker, so that isolate proves
+ * the Go SDK and executables from the plugin cache's records instead of reading
+ * 135 MB of SDK once per bundler or runtime process (samchon/ttsc#1722).
  *
  * @param cached Optional resident generation whose existing source-state and
  *   environment witness may qualify source reuse. Other preparation owners
  *   retain direct source comparison.
- * @evidence contracts/common.md#principled-implementation Every reported plugin directory prepares its actual current environment. The same result's matching manifest state can share source proof only with a healthy exact-source tracker and the environment under which that tree was proven. Otherwise this operation compares source state once and a mismatch refreshes environment authority for the following owning validator to compare again; failed preparation cannot qualify an input.
+ * @param projectRoot Project whose plugin cache holds those records; the
+ *   resident generation's own root when omitted.
+ * @evidence contracts/common.md#principled-implementation Every reported plugin directory qualifies current environment authority; only missing readings require asynchronous preparation. The same result's matching manifest state can share source proof only with a healthy exact-source tracker and the environment under which that tree was proven. Otherwise this operation compares source state once and a mismatch refreshes environment authority for the following owning validator to compare again; failed preparation cannot qualify an input.
  * @evidence contracts/common.md#clear-and-simple-design One async boundary precedes existing synchronous generation, delivery and terminal proofs.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing observations stay unproved; reported binary state never substitutes for native environment preparation or source comparison.
  * @evidence contracts/common.md#meaningful-documentation Native prose identifies off-thread work, mismatch refresh and preserved downstream failure ownership.
  * @evidence contracts/portability.md#os-neutral-implementation The same native toolchain/environment reader and caller filesystem source digest qualify each directory without platform guesses.
- * @evidence contracts/performance.md#efficient-algorithms The envelope selector builds its directory map once per result, and preparation visits each reported directory once. Environment requests build keys from effective variables and qualify native dependencies. A qualified source witness avoids enumeration; other source comparisons enumerate and sort files, check metadata and hash bytes when the digest cannot be reused. A mismatch requests one environment refresh rather than a second source comparison here.
+ * @evidence contracts/performance.md#efficient-algorithms The envelope selector indexes directories once per result. Linear directory passes batch-qualify current readings, prepare missing authority, compare source state and refresh mismatches. Each synchronous batch hashes variables once and shares distinct native dependencies; any preparation await requires another current batch. A qualified source witness avoids enumeration; other source comparisons enumerate and sort files, check metadata and hash bytes when the digest cannot be reused. A mismatch requests one environment refresh rather than a second source comparison here.
  * @evidence contracts/performance.md#reuse-equivalent-work The environment owner shares equivalent in-flight requests and still-qualified readings. Resident source proof is reused only for the exact result and manifest digest, unchanged qualified environment and currently healthy covered source notifications; absent, dirty, replaced or unavailable witnesses retain direct proof. No epoch or quiet watcher alone authorizes reuse, and subsequent admission still owns its current validation.
  * @evidence contracts/performance.md#bound-retention-and-release-resources This module records asynchronous execution ownership in a WeakSet before preparation, including failures, so disposed results are not retained. Requests and worker lifetimes remain with the environment owner; this sequential operation awaits each request and acquires no native observer or independent cancellation handle.
  */
-export declare function preparePluginBuildEnvironments(result: TtscCachedProjectTransform["result"], filesystem: TtscTransformFilesystemOperations, cached?: TtscCachedProjectTransform): Promise<void>;
+export declare function preparePluginBuildEnvironments(result: TtscCachedProjectTransform["result"], filesystem: TtscTransformFilesystemOperations, cached?: TtscCachedProjectTransform, projectRoot?: string | undefined): Promise<void>;
 /**
  * Whether this result's owner attempted asynchronous native preparation. This
  * records execution ownership, never successful observation authority.