@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Sample notification availability after tracker settlement.
+ *
+ * Absence is permitted because recorded-state validation retains its proof; any
+ * present failed observer withdraws notification transfer as a whole. The
+ * caller samples this before subsequent proof admission, preserving the capture
+ * operation's established ordering.
+ *
+ * @evidence contracts/common.md#principled-implementation Every present project, host and candidate tracker must have settled without failure; an absent optional tracker does not invent a failure or coverage claim.
+ * @evidence contracts/common.md#clear-and-simple-design One three-field predicate owns the sampled availability verdict consumed by later retention admission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No observer health is inferred from successful compilation or another healthy tracker, and this operation creates no tracker or native capability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absent versus failed state and the production caller's exact sampling point.
+ * @evidence contracts/portability.md#os-neutral-implementation The actual tracker interface supplies settled failure state independently of backend names and operating systems.
+ * @evidence contracts/performance.md#efficient-algorithms At most three constant-time field reads establish availability without probing the filesystem or native backend again.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call samples current tracker state; the capture caller controls how long that sampled verdict applies.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows tracker references without retaining or releasing their owned observers.
+ */
+function generationNotificationsAvailable(project, host, candidate) {
+    return (project?.failed !== true &&
+        host?.failed !== true &&
+        candidate?.failed !== true);
+}
+/**
+ * Transfer admitted notification authority to one captured generation.
+ *
+ * Actual observer creation, settlement and proof construction remain in the
+ * capture owner. This operation attaches only qualified handles and returns the
+ * exact ownership flags that its caller uses for finally cleanup. The caller
+ * supplies a newly captured generation without prior tracker ownership.
+ * Availability is its earlier settled sample, not a fresh health check
+ * performed here; live tracker consumers still qualify current authority.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires the caller's membership and notification policies, complete generation proof and sampled observer availability together; failure of any premise leaves every tracker with its local cleanup owner.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous admission gate attaches three optional handles and returns their independent ownership flags; acquisition and finally cleanup stay with capture.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied availability sample must cover every present observer rather than infer health from a sibling; missing snapshot authority cannot be promoted to complete proof, and no tracker is manufactured. This gate does not refresh the earlier sample.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the caller-owned creation and settlement steps and the exact cleanup responsibility conveyed by the return value.
+ * @evidence contracts/portability.md#os-neutral-implementation Backend-independent tracker references transfer through their actual lifecycle interface; the gate adds no OS-name or path-case inference.
+ * @evidence contracts/performance.md#efficient-algorithms One Boolean gate and at most three assignments avoid additional native observations or project scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Qualified existing observers transfer with the generation instead of opening equivalent observers again; unavailable authority leaves recorded-state validation responsible for reuse.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Returned flags identify each transferred observer independently, including a candidate when another tracker is absent. The fresh generation gains at most three tracker references, whose watch populations/lifecycle stay with the tracker and disposal owners; this gate does not replace or release pre-existing generation handles. Untransferred handles remain owned by capture finally cleanup attempts.
+ */
+function retainGenerationNotifications(props) {
+    const notifying = props.retainProjectMembership &&
+        props.retainNotifications &&
+        props.stableProjectSnapshot &&
+        props.notificationsAvailable;
+    if (notifying && props.project !== undefined)
+        props.cached.projectMutationTracker = props.project;
+    if (notifying && props.host !== undefined)
+        props.cached.hostInputMutationTracker = props.host;
+    if (notifying && props.candidate !== undefined)
+        props.cached.candidateMutationTracker = props.candidate;
+    return {
+        project: notifying && props.project !== undefined,
+        host: notifying && props.host !== undefined,
+        candidate: notifying && props.candidate !== undefined,
+    };
+}
+
+exports.generationNotificationsAvailable = generationNotificationsAvailable;
+exports.retainGenerationNotifications = retainGenerationNotifications;
+//# sourceMappingURL=retainGenerationNotifications.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retainGenerationNotifications.js","sources":["../../../../src/core/transform/generation/retainGenerationNotifications.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;SACa,gCAAgC,CAC9C,OAA+C,EAC/C,IAA4C,EAC5C,SAAiD,EAAA;AAEjD,IAAA,QACE,OAAO,EAAE,MAAM,KAAK,IAAI;QACxB,IAAI,EAAE,MAAM,KAAK,IAAI;AACrB,QAAA,SAAS,EAAE,MAAM,KAAK,IAAI;AAE9B;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,6BAA6B,CAAC,KAS7C,EAAA;AACC,IAAA,MAAM,SAAS,GACb,KAAK,CAAC,uBAAuB;AAC7B,QAAA,KAAK,CAAC,mBAAmB;AACzB,QAAA,KAAK,CAAC,qBAAqB;QAC3B,KAAK,CAAC,sBAAsB;AAC9B,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAC1C,KAAK,CAAC,MAAM,CAAC,sBAAsB,GAAG,KAAK,CAAC,OAAO;AACrD,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;QACvC,KAAK,CAAC,MAAM,CAAC,wBAAwB,GAAG,KAAK,CAAC,IAAI;AACpD,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;QAC5C,KAAK,CAAC,MAAM,CAAC,wBAAwB,GAAG,KAAK,CAAC,SAAS;IACzD,OAAO;AACL,QAAA,OAAO,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;AACjD,QAAA,IAAI,EAAE,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;AAC3C,QAAA,SAAS,EAAE,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;KACtD;AACH;;;;;"}

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

@@ -0,0 +1,61 @@
+/**
+ * Sample notification availability after tracker settlement.
+ *
+ * Absence is permitted because recorded-state validation retains its proof; any
+ * present failed observer withdraws notification transfer as a whole. The
+ * caller samples this before subsequent proof admission, preserving the capture
+ * operation's established ordering.
+ *
+ * @evidence contracts/common.md#principled-implementation Every present project, host and candidate tracker must have settled without failure; an absent optional tracker does not invent a failure or coverage claim.
+ * @evidence contracts/common.md#clear-and-simple-design One three-field predicate owns the sampled availability verdict consumed by later retention admission.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No observer health is inferred from successful compilation or another healthy tracker, and this operation creates no tracker or native capability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absent versus failed state and the production caller's exact sampling point.
+ * @evidence contracts/portability.md#os-neutral-implementation The actual tracker interface supplies settled failure state independently of backend names and operating systems.
+ * @evidence contracts/performance.md#efficient-algorithms At most three constant-time field reads establish availability without probing the filesystem or native backend again.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call samples current tracker state; the capture caller controls how long that sampled verdict applies.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows tracker references without retaining or releasing their owned observers.
+ */
+function generationNotificationsAvailable(project, host, candidate) {
+    return (project?.failed !== true &&
+        host?.failed !== true &&
+        candidate?.failed !== true);
+}
+/**
+ * Transfer admitted notification authority to one captured generation.
+ *
+ * Actual observer creation, settlement and proof construction remain in the
+ * capture owner. This operation attaches only qualified handles and returns the
+ * exact ownership flags that its caller uses for finally cleanup. The caller
+ * supplies a newly captured generation without prior tracker ownership.
+ * Availability is its earlier settled sample, not a fresh health check
+ * performed here; live tracker consumers still qualify current authority.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires the caller's membership and notification policies, complete generation proof and sampled observer availability together; failure of any premise leaves every tracker with its local cleanup owner.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous admission gate attaches three optional handles and returns their independent ownership flags; acquisition and finally cleanup stay with capture.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied availability sample must cover every present observer rather than infer health from a sibling; missing snapshot authority cannot be promoted to complete proof, and no tracker is manufactured. This gate does not refresh the earlier sample.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the caller-owned creation and settlement steps and the exact cleanup responsibility conveyed by the return value.
+ * @evidence contracts/portability.md#os-neutral-implementation Backend-independent tracker references transfer through their actual lifecycle interface; the gate adds no OS-name or path-case inference.
+ * @evidence contracts/performance.md#efficient-algorithms One Boolean gate and at most three assignments avoid additional native observations or project scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work Qualified existing observers transfer with the generation instead of opening equivalent observers again; unavailable authority leaves recorded-state validation responsible for reuse.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Returned flags identify each transferred observer independently, including a candidate when another tracker is absent. The fresh generation gains at most three tracker references, whose watch populations/lifecycle stay with the tracker and disposal owners; this gate does not replace or release pre-existing generation handles. Untransferred handles remain owned by capture finally cleanup attempts.
+ */
+function retainGenerationNotifications(props) {
+    const notifying = props.retainProjectMembership &&
+        props.retainNotifications &&
+        props.stableProjectSnapshot &&
+        props.notificationsAvailable;
+    if (notifying && props.project !== undefined)
+        props.cached.projectMutationTracker = props.project;
+    if (notifying && props.host !== undefined)
+        props.cached.hostInputMutationTracker = props.host;
+    if (notifying && props.candidate !== undefined)
+        props.cached.candidateMutationTracker = props.candidate;
+    return {
+        project: notifying && props.project !== undefined,
+        host: notifying && props.host !== undefined,
+        candidate: notifying && props.candidate !== undefined,
+    };
+}
+
+export { generationNotificationsAvailable, retainGenerationNotifications };
+//# sourceMappingURL=retainGenerationNotifications.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retainGenerationNotifications.mjs","sources":["../../../../src/core/transform/generation/retainGenerationNotifications.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;AAgBG;SACa,gCAAgC,CAC9C,OAA+C,EAC/C,IAA4C,EAC5C,SAAiD,EAAA;AAEjD,IAAA,QACE,OAAO,EAAE,MAAM,KAAK,IAAI;QACxB,IAAI,EAAE,MAAM,KAAK,IAAI;AACrB,QAAA,SAAS,EAAE,MAAM,KAAK,IAAI;AAE9B;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,6BAA6B,CAAC,KAS7C,EAAA;AACC,IAAA,MAAM,SAAS,GACb,KAAK,CAAC,uBAAuB;AAC7B,QAAA,KAAK,CAAC,mBAAmB;AACzB,QAAA,KAAK,CAAC,qBAAqB;QAC3B,KAAK,CAAC,sBAAsB;AAC9B,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAC1C,KAAK,CAAC,MAAM,CAAC,sBAAsB,GAAG,KAAK,CAAC,OAAO;AACrD,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;QACvC,KAAK,CAAC,MAAM,CAAC,wBAAwB,GAAG,KAAK,CAAC,IAAI;AACpD,IAAA,IAAI,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;QAC5C,KAAK,CAAC,MAAM,CAAC,wBAAwB,GAAG,KAAK,CAAC,SAAS;IACzD,OAAO;AACL,QAAA,OAAO,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;AACjD,QAAA,IAAI,EAAE,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;AAC3C,QAAA,SAAS,EAAE,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;KACtD;AACH;;;;"}

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Select host inputs that survive transform scratch disposal. Exception results
+ * expose no host-input manifest. Native identity also excludes the temporary
+ * wrapper even when its spelling aliases the reported path.
+ *
+ * @evidence contracts/common.md#principled-implementation Producer-listed host paths are normalized by selectListedFiles, then known scratch inputs and the temporary config's filesystem identity are removed because those artifacts are disposed before persistent validation.
+ * @evidence contracts/common.md#clear-and-simple-design This selector owns persistence filtering; envelope decoding, scratch classification and native identity use shared helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusions identify actually disposed adapter-owned artifacts rather than unrelated dependencies or named fixture paths; an exception has no invented host manifest.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains exception and scratch lifetime semantics, while separated props document each optional exclusion boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Host identity uses the supplied filesystem capabilities and excludes aliases through identity keys instead of assuming lexical separators or case prove sameness.
+ * @evidence contracts/performance.md#efficient-algorithms Valid host-list entries first incur native path resolution and full member checks. With no exclusions that fresh list returns directly; otherwise one context and one filter perform scratch/path text checks and cold native identity/ancestor/case observations as needed. The temporary baseline is computed once, but filtering can populate per-path identity storage; entry count alone does not bound text or native IO cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work One local identity context shares repeated path observations and the temporary-config identity is computed once; the returned mutable list is fresh rather than sharing caller mutation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This selector returns path values and owns no observer, descriptor or retained cache lifecycle; generation capture owns subsequent tracking.
+ */
+export declare function selectPersistentHostInputs(props: {
+    /** Native operations used to compare reported aliases with scratch identities. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory anchoring envelope-relative host paths. */
+    projectRoot: string;
+    /** Compiler result whose valid host-input list is selected. */
+    result: ITtscCompilerTransformation;
+    /** Adapter-owned scratch tree removed when capture ends. */
+    scratchDirectory?: string;
+    /** Generated wrapper config, when capture materialized one. */
+    temporaryTsconfig?: string;
+}): string[];

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Select host inputs that survive transform scratch disposal. Exception results
+ * expose no host-input manifest. Native identity also excludes the temporary
+ * wrapper even when its spelling aliases the reported path.
+ *
+ * @evidence contracts/common.md#principled-implementation Producer-listed host paths are normalized by selectListedFiles, then known scratch inputs and the temporary config's filesystem identity are removed because those artifacts are disposed before persistent validation.
+ * @evidence contracts/common.md#clear-and-simple-design This selector owns persistence filtering; envelope decoding, scratch classification and native identity use shared helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusions identify actually disposed adapter-owned artifacts rather than unrelated dependencies or named fixture paths; an exception has no invented host manifest.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains exception and scratch lifetime semantics, while separated props document each optional exclusion boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Host identity uses the supplied filesystem capabilities and excludes aliases through identity keys instead of assuming lexical separators or case prove sameness.
+ * @evidence contracts/performance.md#efficient-algorithms Valid host-list entries first incur native path resolution and full member checks. With no exclusions that fresh list returns directly; otherwise one context and one filter perform scratch/path text checks and cold native identity/ancestor/case observations as needed. The temporary baseline is computed once, but filtering can populate per-path identity storage; entry count alone does not bound text or native IO cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work One local identity context shares repeated path observations and the temporary-config identity is computed once; the returned mutable list is fresh rather than sharing caller mutation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This selector returns path values and owns no observer, descriptor or retained cache lifecycle; generation capture owns subsequent tracking.
+ */
+export declare function selectPersistentHostInputs(props: {
+    /** Native operations used to compare reported aliases with scratch identities. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory anchoring envelope-relative host paths. */
+    projectRoot: string;
+    /** Compiler result whose valid host-input list is selected. */
+    result: ITtscCompilerTransformation;
+    /** Adapter-owned scratch tree removed when capture ends. */
+    scratchDirectory?: string;
+    /** Generated wrapper config, when capture materialized one. */
+    temporaryTsconfig?: string;
+}): string[];

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Select host inputs that survive transform scratch disposal. Exception results
+ * expose no host-input manifest. Native identity also excludes the temporary
+ * wrapper even when its spelling aliases the reported path.
+ *
+ * @evidence contracts/common.md#principled-implementation Producer-listed host paths are normalized by selectListedFiles, then known scratch inputs and the temporary config's filesystem identity are removed because those artifacts are disposed before persistent validation.
+ * @evidence contracts/common.md#clear-and-simple-design This selector owns persistence filtering; envelope decoding, scratch classification and native identity use shared helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusions identify actually disposed adapter-owned artifacts rather than unrelated dependencies or named fixture paths; an exception has no invented host manifest.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains exception and scratch lifetime semantics, while separated props document each optional exclusion boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Host identity uses the supplied filesystem capabilities and excludes aliases through identity keys instead of assuming lexical separators or case prove sameness.
+ * @evidence contracts/performance.md#efficient-algorithms Valid host-list entries first incur native path resolution and full member checks. With no exclusions that fresh list returns directly; otherwise one context and one filter perform scratch/path text checks and cold native identity/ancestor/case observations as needed. The temporary baseline is computed once, but filtering can populate per-path identity storage; entry count alone does not bound text or native IO cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work One local identity context shares repeated path observations and the temporary-config identity is computed once; the returned mutable list is fresh rather than sharing caller mutation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This selector returns path values and owns no observer, descriptor or retained cache lifecycle; generation capture owns subsequent tracking.
+ */
+export declare function selectPersistentHostInputs(props: {
+    /** Native operations used to compare reported aliases with scratch identities. */
+    filesystem: TtscTransformFilesystemOperations;
+    /** Native project directory anchoring envelope-relative host paths. */
+    projectRoot: string;
+    /** Compiler result whose valid host-input list is selected. */
+    result: ITtscCompilerTransformation;
+    /** Adapter-owned scratch tree removed when capture ends. */
+    scratchDirectory?: string;
+    /** Generated wrapper config, when capture materialized one. */
+    temporaryTsconfig?: string;
+}): string[];

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var selectListedFiles = require('../envelope/selectListedFiles.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var isTransformScratchInput = require('../tsconfig/isTransformScratchInput.js');
+
+/**
+ * Select host inputs that survive transform scratch disposal. Exception results
+ * expose no host-input manifest. Native identity also excludes the temporary
+ * wrapper even when its spelling aliases the reported path.
+ *
+ * @evidence contracts/common.md#principled-implementation Producer-listed host paths are normalized by selectListedFiles, then known scratch inputs and the temporary config's filesystem identity are removed because those artifacts are disposed before persistent validation.
+ * @evidence contracts/common.md#clear-and-simple-design This selector owns persistence filtering; envelope decoding, scratch classification and native identity use shared helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusions identify actually disposed adapter-owned artifacts rather than unrelated dependencies or named fixture paths; an exception has no invented host manifest.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains exception and scratch lifetime semantics, while separated props document each optional exclusion boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Host identity uses the supplied filesystem capabilities and excludes aliases through identity keys instead of assuming lexical separators or case prove sameness.
+ * @evidence contracts/performance.md#efficient-algorithms Valid host-list entries first incur native path resolution and full member checks. With no exclusions that fresh list returns directly; otherwise one context and one filter perform scratch/path text checks and cold native identity/ancestor/case observations as needed. The temporary baseline is computed once, but filtering can populate per-path identity storage; entry count alone does not bound text or native IO cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work One local identity context shares repeated path observations and the temporary-config identity is computed once; the returned mutable list is fresh rather than sharing caller mutation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This selector returns path values and owns no observer, descriptor or retained cache lifecycle; generation capture owns subsequent tracking.
+ */
+function selectPersistentHostInputs(props) {
+    if (props.result.type === "exception")
+        return [];
+    const inputs = selectListedFiles.selectListedFiles(props.projectRoot, props.result.hostInputs);
+    if (props.scratchDirectory === undefined &&
+        props.temporaryTsconfig === undefined)
+        return inputs;
+    const identities = createHostPathIdentityContext.createHostPathIdentityContext(props.filesystem);
+    const temporary = props.temporaryTsconfig === undefined
+        ? undefined
+        : pathIdentityKey.pathIdentityKey(props.temporaryTsconfig, identities);
+    return inputs.filter((input) => {
+        if (isTransformScratchInput.isTransformScratchInput(input, props.scratchDirectory))
+            return false;
+        return pathIdentityKey.pathIdentityKey(input, identities) !== temporary;
+    });
+}
+
+exports.selectPersistentHostInputs = selectPersistentHostInputs;
+//# sourceMappingURL=selectPersistentHostInputs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectPersistentHostInputs.js","sources":["../../../../src/core/transform/generation/selectPersistentHostInputs.ts"],"sourcesContent":[null],"names":["selectListedFiles","createHostPathIdentityContext","pathIdentityKey","isTransformScratchInput"],"mappings":";;;;;;;AAQA;;;;;;;;;;;;;AAaG;AACG,SAAU,0BAA0B,CAAC,KAe1C,EAAA;AACC,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW;AAAE,QAAA,OAAO,EAAE;AAChD,IAAA,MAAM,MAAM,GAAGA,mCAAiB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC;AAC5E,IAAA,IACE,KAAK,CAAC,gBAAgB,KAAK,SAAS;QACpC,KAAK,CAAC,iBAAiB,KAAK,SAAS;AAErC,QAAA,OAAO,MAAM;IACf,MAAM,UAAU,GAAGC,2DAA6B,CAAC,KAAK,CAAC,UAAU,CAAC;AAClE,IAAA,MAAM,SAAS,GACb,KAAK,CAAC,iBAAiB,KAAK;AAC1B,UAAE;UACAC,+BAAe,CAAC,KAAK,CAAC,iBAAiB,EAAE,UAAU,CAAC;AAC1D,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,KAAI;AAC7B,QAAA,IAAIC,+CAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC;AAAE,YAAA,OAAO,KAAK;QACxE,OAAOD,+BAAe,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,SAAS;AACzD,IAAA,CAAC,CAAC;AACJ;;;;"}

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

@@ -0,0 +1,39 @@
+import { selectListedFiles } from '../envelope/selectListedFiles.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { isTransformScratchInput } from '../tsconfig/isTransformScratchInput.mjs';
+
+/**
+ * Select host inputs that survive transform scratch disposal. Exception results
+ * expose no host-input manifest. Native identity also excludes the temporary
+ * wrapper even when its spelling aliases the reported path.
+ *
+ * @evidence contracts/common.md#principled-implementation Producer-listed host paths are normalized by selectListedFiles, then known scratch inputs and the temporary config's filesystem identity are removed because those artifacts are disposed before persistent validation.
+ * @evidence contracts/common.md#clear-and-simple-design This selector owns persistence filtering; envelope decoding, scratch classification and native identity use shared helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exclusions identify actually disposed adapter-owned artifacts rather than unrelated dependencies or named fixture paths; an exception has no invented host manifest.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains exception and scratch lifetime semantics, while separated props document each optional exclusion boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation Host identity uses the supplied filesystem capabilities and excludes aliases through identity keys instead of assuming lexical separators or case prove sameness.
+ * @evidence contracts/performance.md#efficient-algorithms Valid host-list entries first incur native path resolution and full member checks. With no exclusions that fresh list returns directly; otherwise one context and one filter perform scratch/path text checks and cold native identity/ancestor/case observations as needed. The temporary baseline is computed once, but filtering can populate per-path identity storage; entry count alone does not bound text or native IO cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work One local identity context shares repeated path observations and the temporary-config identity is computed once; the returned mutable list is fresh rather than sharing caller mutation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This selector returns path values and owns no observer, descriptor or retained cache lifecycle; generation capture owns subsequent tracking.
+ */
+function selectPersistentHostInputs(props) {
+    if (props.result.type === "exception")
+        return [];
+    const inputs = selectListedFiles(props.projectRoot, props.result.hostInputs);
+    if (props.scratchDirectory === undefined &&
+        props.temporaryTsconfig === undefined)
+        return inputs;
+    const identities = createHostPathIdentityContext(props.filesystem);
+    const temporary = props.temporaryTsconfig === undefined
+        ? undefined
+        : pathIdentityKey(props.temporaryTsconfig, identities);
+    return inputs.filter((input) => {
+        if (isTransformScratchInput(input, props.scratchDirectory))
+            return false;
+        return pathIdentityKey(input, identities) !== temporary;
+    });
+}
+
+export { selectPersistentHostInputs };
+//# sourceMappingURL=selectPersistentHostInputs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectPersistentHostInputs.mjs","sources":["../../../../src/core/transform/generation/selectPersistentHostInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAQA;;;;;;;;;;;;;AAaG;AACG,SAAU,0BAA0B,CAAC,KAe1C,EAAA;AACC,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW;AAAE,QAAA,OAAO,EAAE;AAChD,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC;AAC5E,IAAA,IACE,KAAK,CAAC,gBAAgB,KAAK,SAAS;QACpC,KAAK,CAAC,iBAAiB,KAAK,SAAS;AAErC,QAAA,OAAO,MAAM;IACf,MAAM,UAAU,GAAG,6BAA6B,CAAC,KAAK,CAAC,UAAU,CAAC;AAClE,IAAA,MAAM,SAAS,GACb,KAAK,CAAC,iBAAiB,KAAK;AAC1B,UAAE;UACA,eAAe,CAAC,KAAK,CAAC,iBAAiB,EAAE,UAAU,CAAC;AAC1D,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,KAAI;AAC7B,QAAA,IAAI,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC;AAAE,YAAA,OAAO,KAAK;QACxE,OAAO,eAAe,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,SAAS;AACzD,IAAA,CAAC,CAAC;AACJ;;;;"}

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

@@ -0,0 +1,27 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.cjs";
+/**
+ * Replace a capture's provisional compiler comparison rule with its report.
+ *
+ * Capture supplies an explicit priming answer before walking. An exception or
+ * an envelope without a case report leaves that same policy intact. A differing
+ * report marks the old walk for refusal; this operation neither performs the
+ * walk nor establishes that a predicted answer matched the native compiler.
+ *
+ * @evidence contracts/common.md#principled-implementation An available compiler boolean, including false, overrides the explicit priming answer; equality determines whether the capture learned a different rule. Missing reports retain the original policy identity.
+ * @evidence contracts/common.md#clear-and-simple-design One report-selection operation returns the policy and changed-rule fact; capture retains ownership of enumeration authority and proof refusal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No OS label or filesystem probe substitutes for a compiler report, and no report supplies missing walk evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the explicit primer requirement, missing-report identity and changed-policy refusal boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler's reported comparison policy wins independently of host path grammar; the explicit primer remains provisional and native prediction or probing is outside this operation.
+ * @evidence contracts/performance.md#efficient-algorithms Missing reports return the borrowed policy; an available report shallow-copies its own fields once. Work and temporary object space follow policy field count, without traversing nested specifications.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Selects this envelope's reported rule without retaining a memo or certifying reuse of the primed walk.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrows the primer or returns a shallow policy object; capture owns retained policy and observer lifetimes, with no handle or historical state acquired here.
+ */
+export declare function selectReportedMembershipPolicy(primed: ITtscProjectMembershipPolicy & {
+    useCaseSensitiveFileNames: boolean;
+}, result: ITtscCompilerTransformation): {
+    /** Borrowed primer or reported-case overlay for this capture's validators. */
+    membershipPolicy: ITtscProjectMembershipPolicy;
+    /** Whether the primed walk used a different rule from this compiler report. */
+    casePolicyLearned: boolean;
+};

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

@@ -0,0 +1,27 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy.mjs";
+/**
+ * Replace a capture's provisional compiler comparison rule with its report.
+ *
+ * Capture supplies an explicit priming answer before walking. An exception or
+ * an envelope without a case report leaves that same policy intact. A differing
+ * report marks the old walk for refusal; this operation neither performs the
+ * walk nor establishes that a predicted answer matched the native compiler.
+ *
+ * @evidence contracts/common.md#principled-implementation An available compiler boolean, including false, overrides the explicit priming answer; equality determines whether the capture learned a different rule. Missing reports retain the original policy identity.
+ * @evidence contracts/common.md#clear-and-simple-design One report-selection operation returns the policy and changed-rule fact; capture retains ownership of enumeration authority and proof refusal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No OS label or filesystem probe substitutes for a compiler report, and no report supplies missing walk evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the explicit primer requirement, missing-report identity and changed-policy refusal boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler's reported comparison policy wins independently of host path grammar; the explicit primer remains provisional and native prediction or probing is outside this operation.
+ * @evidence contracts/performance.md#efficient-algorithms Missing reports return the borrowed policy; an available report shallow-copies its own fields once. Work and temporary object space follow policy field count, without traversing nested specifications.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Selects this envelope's reported rule without retaining a memo or certifying reuse of the primed walk.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrows the primer or returns a shallow policy object; capture owns retained policy and observer lifetimes, with no handle or historical state acquired here.
+ */
+export declare function selectReportedMembershipPolicy(primed: ITtscProjectMembershipPolicy & {
+    useCaseSensitiveFileNames: boolean;
+}, result: ITtscCompilerTransformation): {
+    /** Borrowed primer or reported-case overlay for this capture's validators. */
+    membershipPolicy: ITtscProjectMembershipPolicy;
+    /** Whether the primed walk used a different rule from this compiler report. */
+    casePolicyLearned: boolean;
+};

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

@@ -0,0 +1,27 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { ITtscProjectMembershipPolicy } from "../../tsconfig/ITtscProjectMembershipPolicy";
+/**
+ * Replace a capture's provisional compiler comparison rule with its report.
+ *
+ * Capture supplies an explicit priming answer before walking. An exception or
+ * an envelope without a case report leaves that same policy intact. A differing
+ * report marks the old walk for refusal; this operation neither performs the
+ * walk nor establishes that a predicted answer matched the native compiler.
+ *
+ * @evidence contracts/common.md#principled-implementation An available compiler boolean, including false, overrides the explicit priming answer; equality determines whether the capture learned a different rule. Missing reports retain the original policy identity.
+ * @evidence contracts/common.md#clear-and-simple-design One report-selection operation returns the policy and changed-rule fact; capture retains ownership of enumeration authority and proof refusal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No OS label or filesystem probe substitutes for a compiler report, and no report supplies missing walk evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the explicit primer requirement, missing-report identity and changed-policy refusal boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler's reported comparison policy wins independently of host path grammar; the explicit primer remains provisional and native prediction or probing is outside this operation.
+ * @evidence contracts/performance.md#efficient-algorithms Missing reports return the borrowed policy; an available report shallow-copies its own fields once. Work and temporary object space follow policy field count, without traversing nested specifications.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Selects this envelope's reported rule without retaining a memo or certifying reuse of the primed walk.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrows the primer or returns a shallow policy object; capture owns retained policy and observer lifetimes, with no handle or historical state acquired here.
+ */
+export declare function selectReportedMembershipPolicy(primed: ITtscProjectMembershipPolicy & {
+    useCaseSensitiveFileNames: boolean;
+}, result: ITtscCompilerTransformation): {
+    /** Borrowed primer or reported-case overlay for this capture's validators. */
+    membershipPolicy: ITtscProjectMembershipPolicy;
+    /** Whether the primed walk used a different rule from this compiler report. */
+    casePolicyLearned: boolean;
+};

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

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Replace a capture's provisional compiler comparison rule with its report.
+ *
+ * Capture supplies an explicit priming answer before walking. An exception or
+ * an envelope without a case report leaves that same policy intact. A differing
+ * report marks the old walk for refusal; this operation neither performs the
+ * walk nor establishes that a predicted answer matched the native compiler.
+ *
+ * @evidence contracts/common.md#principled-implementation An available compiler boolean, including false, overrides the explicit priming answer; equality determines whether the capture learned a different rule. Missing reports retain the original policy identity.
+ * @evidence contracts/common.md#clear-and-simple-design One report-selection operation returns the policy and changed-rule fact; capture retains ownership of enumeration authority and proof refusal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No OS label or filesystem probe substitutes for a compiler report, and no report supplies missing walk evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the explicit primer requirement, missing-report identity and changed-policy refusal boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler's reported comparison policy wins independently of host path grammar; the explicit primer remains provisional and native prediction or probing is outside this operation.
+ * @evidence contracts/performance.md#efficient-algorithms Missing reports return the borrowed policy; an available report shallow-copies its own fields once. Work and temporary object space follow policy field count, without traversing nested specifications.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Selects this envelope's reported rule without retaining a memo or certifying reuse of the primed walk.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrows the primer or returns a shallow policy object; capture owns retained policy and observer lifetimes, with no handle or historical state acquired here.
+ */
+function selectReportedMembershipPolicy(primed, result) {
+    const reported = result.type === "exception"
+        ? undefined
+        : result.graph?.useCaseSensitiveFileNames;
+    return {
+        membershipPolicy: reported === undefined
+            ? primed
+            : { ...primed, useCaseSensitiveFileNames: reported },
+        casePolicyLearned: reported !== undefined && reported !== primed.useCaseSensitiveFileNames,
+    };
+}
+
+exports.selectReportedMembershipPolicy = selectReportedMembershipPolicy;
+//# sourceMappingURL=selectReportedMembershipPolicy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReportedMembershipPolicy.js","sources":["../../../../src/core/transform/generation/selectReportedMembershipPolicy.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,8BAA8B,CAC5C,MAA6E,EAC7E,MAAmC,EAAA;AAQnC,IAAA,MAAM,QAAQ,GACZ,MAAM,CAAC,IAAI,KAAK;AACd,UAAE;AACF,UAAE,MAAM,CAAC,KAAK,EAAE,yBAAyB;IAC7C,OAAO;QACL,gBAAgB,EACd,QAAQ,KAAK;AACX,cAAE;cACA,EAAE,GAAG,MAAM,EAAE,yBAAyB,EAAE,QAAQ,EAAE;QACxD,iBAAiB,EACf,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,MAAM,CAAC,yBAAyB;KAC1E;AACH;;;;"}

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

@@ -0,0 +1,31 @@
+/**
+ * Replace a capture's provisional compiler comparison rule with its report.
+ *
+ * Capture supplies an explicit priming answer before walking. An exception or
+ * an envelope without a case report leaves that same policy intact. A differing
+ * report marks the old walk for refusal; this operation neither performs the
+ * walk nor establishes that a predicted answer matched the native compiler.
+ *
+ * @evidence contracts/common.md#principled-implementation An available compiler boolean, including false, overrides the explicit priming answer; equality determines whether the capture learned a different rule. Missing reports retain the original policy identity.
+ * @evidence contracts/common.md#clear-and-simple-design One report-selection operation returns the policy and changed-rule fact; capture retains ownership of enumeration authority and proof refusal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No OS label or filesystem probe substitutes for a compiler report, and no report supplies missing walk evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the explicit primer requirement, missing-report identity and changed-policy refusal boundary.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiler's reported comparison policy wins independently of host path grammar; the explicit primer remains provisional and native prediction or probing is outside this operation.
+ * @evidence contracts/performance.md#efficient-algorithms Missing reports return the borrowed policy; an available report shallow-copies its own fields once. Work and temporary object space follow policy field count, without traversing nested specifications.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Selects this envelope's reported rule without retaining a memo or certifying reuse of the primed walk.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrows the primer or returns a shallow policy object; capture owns retained policy and observer lifetimes, with no handle or historical state acquired here.
+ */
+function selectReportedMembershipPolicy(primed, result) {
+    const reported = result.type === "exception"
+        ? undefined
+        : result.graph?.useCaseSensitiveFileNames;
+    return {
+        membershipPolicy: reported === undefined
+            ? primed
+            : { ...primed, useCaseSensitiveFileNames: reported },
+        casePolicyLearned: reported !== undefined && reported !== primed.useCaseSensitiveFileNames,
+    };
+}
+
+export { selectReportedMembershipPolicy };
+//# sourceMappingURL=selectReportedMembershipPolicy.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReportedMembershipPolicy.mjs","sources":["../../../../src/core/transform/generation/selectReportedMembershipPolicy.ts"],"sourcesContent":[null],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,8BAA8B,CAC5C,MAA6E,EAC7E,MAAmC,EAAA;AAQnC,IAAA,MAAM,QAAQ,GACZ,MAAM,CAAC,IAAI,KAAK;AACd,UAAE;AACF,UAAE,MAAM,CAAC,KAAK,EAAE,yBAAyB;IAC7C,OAAO;QACL,gBAAgB,EACd,QAAQ,KAAK;AACX,cAAE;cACA,EAAE,GAAG,MAAM,EAAE,yBAAyB,EAAE,QAAQ,EAAE;QACxD,iBAAiB,EACf,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,MAAM,CAAC,yBAAyB;KAC1E;AACH;;;;"}

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

@@ -0,0 +1,87 @@
+import type { TtscAdoptionVerdict } from "../session/TtscAdoptionVerdict.cjs";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/**
+ * Select how one completed capture spends the retry owner's budgets. Supplied
+ * facts describe the capture; this policy performs no capture or native proof.
+ *
+ * Coherent results return first. A local, lossless host-observation refusal can
+ * transfer an incomplete local success. TtscGenerationProof owns any sharing of
+ * its first module deliveries inside an explicit nonwatching pass; this policy
+ * grants no independent native or persistent proof. Rejected attempts spend
+ * movement only when they neither refute a publication nor solely learn facts.
+ * Two movements or four captures stop retrying, retaining a current diagnostic
+ * rather than a terminal instability verdict when its config is not refuted.
+ *
+ * The caller owns learned dependency/case carry, terminal validation, capture
+ * disposal and result transfer. Selecting terminal does not certify a baseline
+ * or cleanup, and selecting accepted does not independently prove input facts.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Capture flags govern coherent acceptance before retry classification. Only
+ *   local stable successes with nonempty lossless host-unavailable failures get
+ *   fresh-only transfer; refuted publication and learned-only exemptions retain
+ *   the absolute cap, while other failures consume the movement budget.
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   A pure disposition returns classification and next scalar retry state;
+ *   capture, mutable learning, validation lookup and cleanup remain caller-owned.
+ *   Accepted and fresh-only literal variants stay separate so their exclusion
+ *   leaves only dispositions carrying rejection state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   No native backend substitution or test injection bypasses capture. Omitted,
+ *   mixed and empty failures cannot establish the learned or fresh exemption.
+ * @evidence contracts/common.md#meaningful-documentation
+ *   Prose distinguishes acceptance, fresh transfer, bounded rejection and the
+ *   caller's actual proof/resource responsibilities without claiming execution.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Classifies logical result flags, opaque publication keys and failure kinds;
+ *   it interprets no native coordinate, filesystem capability or process value.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Scalar guards precede at most two short-circuit failure scans. Work follows
+ *   supplied entry count and kind text; no dependency population is copied here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Each capture's supplied flags and budgets can differ; classification stores
+ *   no memo and grants no authority to reuse a prior capture's native proof.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Results borrow the supplied failure aggregate or transfer a fresh empty one.
+ *   No handle, task or historical state is retained; the caller owns attempts,
+ *   terminal baselines and rejected-capture disposal.
+ */
+export declare function selectTransformAttemptDisposition(props: {
+    /** Compiler envelope discriminator of this completed capture. */
+    resultType: "success" | "failure" | "exception";
+    /** Explicit config coherence; undefined retains the existing admission rule. */
+    configStateComplete?: boolean;
+    /** Reusable project success proof, required explicitly for success acceptance. */
+    projectSnapshotComplete?: boolean;
+    /** Capture-window stability; diagnostic acceptance rejects explicit false. */
+    projectHeldStill?: boolean;
+    /** Failure-envelope host observation completeness. */
+    observationsComplete?: boolean;
+    /** Number of producer-reported host proof failure entries. */
+    hostInputProofFailureCount: number;
+    /**
+     * Optional recorded proof aggregate; absent rejection starts with empty
+     * evidence.
+     */
+    failures?: TtscGenerationProofFailures;
+    /** Publication origin and refutation, absent for a locally compiled attempt. */
+    adopted?: TtscAdoptionVerdict;
+    /** Zero-based index of this capture within the current retry loop. */
+    attempt: number;
+    /** Movement failures counted before this capture. */
+    moved: number;
+    /** Exact publication payload the caller's next capture must refuse, if any. */
+    rejected?: string;
+}): {
+    kind: "accepted";
+    freshDeliveryOnly: boolean;
+} | {
+    kind: "fresh-only";
+    freshDeliveryOnly: boolean;
+} | {
+    kind: "retry" | "diagnostic" | "terminal";
+    freshDeliveryOnly: boolean;
+    failures: TtscGenerationProofFailures;
+    moved: number;
+    rejected: string | undefined;
+};