@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,35 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Whether one plugin source directory still holds the state a transform
+ * reported for it: its sources and the environment a build there is keyed on
+ * (`pluginSourceStateHolds` from `ttsc/plugin-source`, samchon/ttsc#1493).
+ *
+ * The shared state owner reuses a build-environment reading while its toolchain
+ * witnesses hold, and refreshes that environment before rejecting a mismatch.
+ * This avoids repeatedly rejecting a new build solely because the consumer
+ * retained an older environment reading.
+ *
+ * The source digest is reused only while metadata and fresh clock-separability
+ * evidence permit it. Otherwise source bytes are read again. Unavailable source
+ * or environment observations return false rather than proving unchanged state.
+ * Async generation and delivery owners can supply an environment they just
+ * qualified through the shared reading owner. That path performs no cold native
+ * fallback; unavailable authority returns false and its async owner prepares a
+ * fresh reading before admitting a replacement.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @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.
+ * @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.
+ * @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;

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

@@ -0,0 +1,35 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Whether one plugin source directory still holds the state a transform
+ * reported for it: its sources and the environment a build there is keyed on
+ * (`pluginSourceStateHolds` from `ttsc/plugin-source`, samchon/ttsc#1493).
+ *
+ * The shared state owner reuses a build-environment reading while its toolchain
+ * witnesses hold, and refreshes that environment before rejecting a mismatch.
+ * This avoids repeatedly rejecting a new build solely because the consumer
+ * retained an older environment reading.
+ *
+ * The source digest is reused only while metadata and fresh clock-separability
+ * evidence permit it. Otherwise source bytes are read again. Unavailable source
+ * or environment observations return false rather than proving unchanged state.
+ * Async generation and delivery owners can supply an environment they just
+ * qualified through the shared reading owner. That path performs no cold native
+ * fallback; unavailable authority returns false and its async owner prepares a
+ * fresh reading before admitting a replacement.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @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.
+ * @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.
+ * @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;

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

@@ -0,0 +1,35 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Whether one plugin source directory still holds the state a transform
+ * reported for it: its sources and the environment a build there is keyed on
+ * (`pluginSourceStateHolds` from `ttsc/plugin-source`, samchon/ttsc#1493).
+ *
+ * The shared state owner reuses a build-environment reading while its toolchain
+ * witnesses hold, and refreshes that environment before rejecting a mismatch.
+ * This avoids repeatedly rejecting a new build solely because the consumer
+ * retained an older environment reading.
+ *
+ * The source digest is reused only while metadata and fresh clock-separability
+ * evidence permit it. Otherwise source bytes are read again. Unavailable source
+ * or environment observations return false rather than proving unchanged state.
+ * Async generation and delivery owners can supply an environment they just
+ * qualified through the shared reading owner. That path performs no cold native
+ * fallback; unavailable authority returns false and its async owner prepares a
+ * fresh reading before admitting a replacement.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @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.
+ * @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.
+ * @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;

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

@@ -0,0 +1,55 @@
+'use strict';
+
+var pluginSource = require('ttsc/plugin-source');
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var pluginSourceFilesDigest = require('./pluginSourceFilesDigest.js');
+
+/**
+ * Whether one plugin source directory still holds the state a transform
+ * reported for it: its sources and the environment a build there is keyed on
+ * (`pluginSourceStateHolds` from `ttsc/plugin-source`, samchon/ttsc#1493).
+ *
+ * The shared state owner reuses a build-environment reading while its toolchain
+ * witnesses hold, and refreshes that environment before rejecting a mismatch.
+ * This avoids repeatedly rejecting a new build solely because the consumer
+ * retained an older environment reading.
+ *
+ * The source digest is reused only while metadata and fresh clock-separability
+ * evidence permit it. Otherwise source bytes are read again. Unavailable source
+ * or environment observations return false rather than proving unchanged state.
+ * Async generation and delivery owners can supply an environment they just
+ * qualified through the shared reading owner. That path performs no cold native
+ * fallback; unavailable authority returns false and its async owner prepares a
+ * fresh reading before admitting a replacement.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @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.
+ * @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.
+ * @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) {
+    try {
+        const sourceDigest = pluginSourceFilesDigest.pluginSourceFilesDigest(directory, filesystem);
+        if (prepared !== undefined)
+            return (prepared.environment !== undefined &&
+                pluginSource.pluginSourceState(directory, {
+                    environment: prepared.environment,
+                    sourceDigest,
+                }) === state);
+        return pluginSource.pluginSourceStateHolds(directory, state, { sourceDigest });
+    }
+    catch {
+        return false;
+    }
+}
+
+exports.pluginSourceHolds = pluginSourceHolds;
+//# sourceMappingURL=pluginSourceHolds.js.map

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

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

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

@@ -0,0 +1,53 @@
+import { pluginSourceState, pluginSourceStateHolds } from 'ttsc/plugin-source';
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { pluginSourceFilesDigest } from './pluginSourceFilesDigest.mjs';
+
+/**
+ * Whether one plugin source directory still holds the state a transform
+ * reported for it: its sources and the environment a build there is keyed on
+ * (`pluginSourceStateHolds` from `ttsc/plugin-source`, samchon/ttsc#1493).
+ *
+ * The shared state owner reuses a build-environment reading while its toolchain
+ * witnesses hold, and refreshes that environment before rejecting a mismatch.
+ * This avoids repeatedly rejecting a new build solely because the consumer
+ * retained an older environment reading.
+ *
+ * The source digest is reused only while metadata and fresh clock-separability
+ * evidence permit it. Otherwise source bytes are read again. Unavailable source
+ * or environment observations return false rather than proving unchanged state.
+ * Async generation and delivery owners can supply an environment they just
+ * qualified through the shared reading owner. That path performs no cold native
+ * fallback; unavailable authority returns false and its async owner prepares a
+ * fresh reading before admitting a replacement.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @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.
+ * @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.
+ * @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) {
+    try {
+        const sourceDigest = pluginSourceFilesDigest(directory, filesystem);
+        if (prepared !== undefined)
+            return (prepared.environment !== undefined &&
+                pluginSourceState(directory, {
+                    environment: prepared.environment,
+                    sourceDigest,
+                }) === state);
+        return pluginSourceStateHolds(directory, state, { sourceDigest });
+    }
+    catch {
+        return false;
+    }
+}
+
+export { pluginSourceHolds };
+//# sourceMappingURL=pluginSourceHolds.mjs.map

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * The current state of one plugin source directory, by the rule the plugin
+ * build keyed its binary on: its sources and the environment a build there is
+ * keyed on (`pluginSourceState` from `ttsc/plugin-source`, samchon/ttsc#1487,
+ * samchon/ttsc#1493), or `null` when it cannot be read now.
+ *
+ * A capture records it: an observer's baseline for a registered plugin source,
+ * a failed generation's input state, and Metro's key. A proof against a state
+ * the envelope or a record carries compares through `pluginSourceHolds`
+ * instead, which reads the build environment again before it refutes the state.
+ * So a restart, an adopter, or a host's persistent cache under another
+ * `GOFLAGS` or Go toolchain refuses output the old binary produced, as it
+ * refuses output of an edited source. A directory a file below could not be
+ * read from proves nothing, so `null` never equals a recorded state.
+ *
+ * Async terminal confirmation supplies already-qualified environment authority
+ * instead of starting cold native work on the host thread. Other synchronous
+ * capture callers retain the shared reader's original observation behavior.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @param prepared Optional current environment prepared by the async owner.
+ * @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.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs identify capture consumers, proof delegation, environment changes and null meaning, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral state observes the shared source and Go/toolchain environment boundaries used by native builds instead of inferring equivalence from one platform name or assumed tool location.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; a failure becomes null.
+ * @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.
+ */
+export declare function pluginSourceState(directory: string, prepared?: {
+    environment: string | undefined;
+}): string | null;

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

@@ -0,0 +1,33 @@
+/**
+ * The current state of one plugin source directory, by the rule the plugin
+ * build keyed its binary on: its sources and the environment a build there is
+ * keyed on (`pluginSourceState` from `ttsc/plugin-source`, samchon/ttsc#1487,
+ * samchon/ttsc#1493), or `null` when it cannot be read now.
+ *
+ * A capture records it: an observer's baseline for a registered plugin source,
+ * a failed generation's input state, and Metro's key. A proof against a state
+ * the envelope or a record carries compares through `pluginSourceHolds`
+ * instead, which reads the build environment again before it refutes the state.
+ * So a restart, an adopter, or a host's persistent cache under another
+ * `GOFLAGS` or Go toolchain refuses output the old binary produced, as it
+ * refuses output of an edited source. A directory a file below could not be
+ * read from proves nothing, so `null` never equals a recorded state.
+ *
+ * Async terminal confirmation supplies already-qualified environment authority
+ * instead of starting cold native work on the host thread. Other synchronous
+ * capture callers retain the shared reader's original observation behavior.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @param prepared Optional current environment prepared by the async owner.
+ * @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.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs identify capture consumers, proof delegation, environment changes and null meaning, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral state observes the shared source and Go/toolchain environment boundaries used by native builds instead of inferring equivalence from one platform name or assumed tool location.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; a failure becomes null.
+ * @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.
+ */
+export declare function pluginSourceState(directory: string, prepared?: {
+    environment: string | undefined;
+}): string | null;

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

@@ -0,0 +1,33 @@
+/**
+ * The current state of one plugin source directory, by the rule the plugin
+ * build keyed its binary on: its sources and the environment a build there is
+ * keyed on (`pluginSourceState` from `ttsc/plugin-source`, samchon/ttsc#1487,
+ * samchon/ttsc#1493), or `null` when it cannot be read now.
+ *
+ * A capture records it: an observer's baseline for a registered plugin source,
+ * a failed generation's input state, and Metro's key. A proof against a state
+ * the envelope or a record carries compares through `pluginSourceHolds`
+ * instead, which reads the build environment again before it refutes the state.
+ * So a restart, an adopter, or a host's persistent cache under another
+ * `GOFLAGS` or Go toolchain refuses output the old binary produced, as it
+ * refuses output of an edited source. A directory a file below could not be
+ * read from proves nothing, so `null` never equals a recorded state.
+ *
+ * Async terminal confirmation supplies already-qualified environment authority
+ * instead of starting cold native work on the host thread. Other synchronous
+ * capture callers retain the shared reader's original observation behavior.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @param prepared Optional current environment prepared by the async owner.
+ * @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.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs identify capture consumers, proof delegation, environment changes and null meaning, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral state observes the shared source and Go/toolchain environment boundaries used by native builds instead of inferring equivalence from one platform name or assumed tool location.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; a failure becomes null.
+ * @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.
+ */
+export declare function pluginSourceState(directory: string, prepared?: {
+    environment: string | undefined;
+}): string | null;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var pluginSource = require('ttsc/plugin-source');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var pluginSource__namespace = /*#__PURE__*/_interopNamespaceDefault(pluginSource);
+
+/**
+ * The current state of one plugin source directory, by the rule the plugin
+ * build keyed its binary on: its sources and the environment a build there is
+ * keyed on (`pluginSourceState` from `ttsc/plugin-source`, samchon/ttsc#1487,
+ * samchon/ttsc#1493), or `null` when it cannot be read now.
+ *
+ * A capture records it: an observer's baseline for a registered plugin source,
+ * a failed generation's input state, and Metro's key. A proof against a state
+ * the envelope or a record carries compares through `pluginSourceHolds`
+ * instead, which reads the build environment again before it refutes the state.
+ * So a restart, an adopter, or a host's persistent cache under another
+ * `GOFLAGS` or Go toolchain refuses output the old binary produced, as it
+ * refuses output of an edited source. A directory a file below could not be
+ * read from proves nothing, so `null` never equals a recorded state.
+ *
+ * Async terminal confirmation supplies already-qualified environment authority
+ * instead of starting cold native work on the host thread. Other synchronous
+ * capture callers retain the shared reader's original observation behavior.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @param prepared Optional current environment prepared by the async owner.
+ * @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.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs identify capture consumers, proof delegation, environment changes and null meaning, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral state observes the shared source and Go/toolchain environment boundaries used by native builds instead of inferring equivalence from one platform name or assumed tool location.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; a failure becomes null.
+ * @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) {
+    try {
+        if (prepared !== undefined)
+            return prepared.environment === undefined
+                ? null
+                : pluginSource__namespace.pluginSourceState(directory, prepared);
+        return pluginSource__namespace.pluginSourceState(directory);
+    }
+    catch {
+        return null;
+    }
+}
+
+exports.pluginSourceState = pluginSourceState;
+//# sourceMappingURL=pluginSourceState.js.map

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

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

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

@@ -0,0 +1,47 @@
+import * as pluginSource from 'ttsc/plugin-source';
+
+/**
+ * The current state of one plugin source directory, by the rule the plugin
+ * build keyed its binary on: its sources and the environment a build there is
+ * keyed on (`pluginSourceState` from `ttsc/plugin-source`, samchon/ttsc#1487,
+ * samchon/ttsc#1493), or `null` when it cannot be read now.
+ *
+ * A capture records it: an observer's baseline for a registered plugin source,
+ * a failed generation's input state, and Metro's key. A proof against a state
+ * the envelope or a record carries compares through `pluginSourceHolds`
+ * instead, which reads the build environment again before it refutes the state.
+ * So a restart, an adopter, or a host's persistent cache under another
+ * `GOFLAGS` or Go toolchain refuses output the old binary produced, as it
+ * refuses output of an edited source. A directory a file below could not be
+ * read from proves nothing, so `null` never equals a recorded state.
+ *
+ * Async terminal confirmation supplies already-qualified environment authority
+ * instead of starting cold native work on the host thread. Other synchronous
+ * capture callers retain the shared reader's original observation behavior.
+ *
+ * @param directory The source directory, as the envelope names it.
+ * @param prepared Optional current environment prepared by the async owner.
+ * @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.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs identify capture consumers, proof delegation, environment changes and null meaning, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral state observes the shared source and Go/toolchain environment boundaries used by native builds instead of inferring equivalence from one platform name or assumed tool location.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; a failure becomes null.
+ * @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) {
+    try {
+        if (prepared !== undefined)
+            return prepared.environment === undefined
+                ? null
+                : pluginSource.pluginSourceState(directory, prepared);
+        return pluginSource.pluginSourceState(directory);
+    }
+    catch {
+        return null;
+    }
+}
+
+export { pluginSourceState };
+//# sourceMappingURL=pluginSourceState.mjs.map

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

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

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Prepare 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.
+ *
+ * @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.
+ * @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#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>;
+/**
+ * Whether this result's owner attempted asynchronous native preparation. This
+ * records execution ownership, never successful observation authority.
+ *
+ * @evidence contracts/common.md#principled-implementation Result identity distinguishes async-owned proof from a standalone synchronous observation; membership does not certify any environment reading.
+ * @evidence contracts/common.md#clear-and-simple-design One identity query selects which execution owner may prepare missing native authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed preparation also records async ownership, preventing an accidental cold synchronous fallback or fabricated successful proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates execution responsibility from reading validity.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Identity membership performs no native operation.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed identity query selects an existing execution policy; it chooses no traversal or processing strategy and performs no toolchain probe.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The query selects an execution policy, not a reusable native observation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The preparation operation owns weak identity registration; this query borrows that record and acquires or retains no additional resource.
+ */
+export declare function usesPreparedPluginBuildEnvironments(result: TtscCachedProjectTransform["result"]): boolean;

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Prepare 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.
+ *
+ * @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.
+ * @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#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>;
+/**
+ * Whether this result's owner attempted asynchronous native preparation. This
+ * records execution ownership, never successful observation authority.
+ *
+ * @evidence contracts/common.md#principled-implementation Result identity distinguishes async-owned proof from a standalone synchronous observation; membership does not certify any environment reading.
+ * @evidence contracts/common.md#clear-and-simple-design One identity query selects which execution owner may prepare missing native authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed preparation also records async ownership, preventing an accidental cold synchronous fallback or fabricated successful proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates execution responsibility from reading validity.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Identity membership performs no native operation.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed identity query selects an existing execution policy; it chooses no traversal or processing strategy and performs no toolchain probe.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The query selects an execution policy, not a reusable native observation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The preparation operation owns weak identity registration; this query borrows that record and acquires or retains no additional resource.
+ */
+export declare function usesPreparedPluginBuildEnvironments(result: TtscCachedProjectTransform["result"]): boolean;

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Prepare 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.
+ *
+ * @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.
+ * @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#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>;
+/**
+ * Whether this result's owner attempted asynchronous native preparation. This
+ * records execution ownership, never successful observation authority.
+ *
+ * @evidence contracts/common.md#principled-implementation Result identity distinguishes async-owned proof from a standalone synchronous observation; membership does not certify any environment reading.
+ * @evidence contracts/common.md#clear-and-simple-design One identity query selects which execution owner may prepare missing native authority.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed preparation also records async ownership, preventing an accidental cold synchronous fallback or fabricated successful proof.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates execution responsibility from reading validity.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Identity membership performs no native operation.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The fixed identity query selects an existing execution policy; it chooses no traversal or processing strategy and performs no toolchain probe.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The query selects an execution policy, not a reusable native observation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The preparation operation owns weak identity registration; this query borrows that record and acquires or retains no additional resource.
+ */
+export declare function usesPreparedPluginBuildEnvironments(result: TtscCachedProjectTransform["result"]): boolean;