@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var path = require('node:path');
+var disposeCachedTransform = require('../cache/disposeCachedTransform.js');
+var TtscUnstableGenerationError = require('../errors/TtscUnstableGenerationError.js');
+
+/** Render one input without leaking source content or control characters. */
+function formatGenerationFailurePath(projectRoot, input) {
+    const absolute = path.resolve(input);
+    const relative = path.relative(projectRoot, absolute);
+    const display = relative === ""
+        ? "."
+        : relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)
+            ? relative
+            : absolute;
+    return JSON.stringify(display.split(path.sep).join("/"));
+}
+/**
+ * Build the terminal error shared by waiters of an unstable generation, with
+ * bounded per-attempt witnesses and a retained retry comparison baseline. Live
+ * generation fields detach and their cleanup is attempted before the error
+ * retains that data; failed native cleanup is not certified released. Producer
+ * details and native paths are JSON-escaped for safe diagnostics.
+ *
+ * @evidence contracts/common.md#principled-implementation Each attempted proof contributes its classified witnesses and omitted count, while absent retained entries remain an explicit incomplete proof; the validation baseline identifies the environment that can authorize retry.
+ * @evidence contracts/common.md#clear-and-simple-design Error rendering stays here, path attribution uses one private formatter and live generation disposal delegates to the shared lifecycle owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unstable proof is reported rather than converted into reusable output; dropped witnesses remain visible and diagnostic control characters cannot create fictitious lines.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes shared terminal error data from released live resources and explains bounded witnesses and escaped producer input.
+ * @evidence contracts/portability.md#os-neutral-implementation Native relative-path classification uses Node path semantics; slash rendering is only diagnostic presentation and does not change filesystem identity or project ownership.
+ * @evidence contracts/performance.md#efficient-algorithms Rendering visits each attempt and retained witness once, with native path processing and escaping driven by diagnostic text lengths; delegated disposal also closes the final attempt's retained watchers without rescanning source contents.
+ * @evidence contracts/performance.md#reuse-equivalent-work transformProject creates one terminal verdict for its failed attempt sequence, and cache waiters share that error instead of separately rerendering or recompiling the same unchanged environment.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The shared disposer detaches watcher/probe ownership and attempts each cleanup before the error retains comparison data. Failed native close/removal can leave underlying resources; the error does not acquire their handles or claim cleanup succeeded. Retained comparison/witness text has cache-owner lifetime and no byte bound from the witness-count cap.
+ */
+function createUnstableGenerationError(projectRoot, attempts, validation) {
+    const lines = [
+        `ttsc: could not capture a reusable transform generation after ${attempts.length} attempts.`,
+        `  project: ${JSON.stringify(projectRoot)}`,
+    ];
+    attempts.forEach((failures, index) => {
+        lines.push(`  attempt ${index + 1}:`);
+        if (failures.entries.length === 0) {
+            lines.push("    - project/generation-proof-incomplete");
+        }
+        for (const failure of failures.entries) {
+            const input = failure.path === undefined
+                ? ""
+                : `: ${formatGenerationFailurePath(projectRoot, failure.path)}`;
+            const detail = failure.detail === undefined
+                ? ""
+                : ` (producer: ${JSON.stringify(failure.detail)})`;
+            lines.push(`    - ${failure.domain}/${failure.kind}${input}${detail}`);
+        }
+        if (failures.omitted !== 0) {
+            lines.push(`    - ... ${failures.omitted} additional witness(es) omitted`);
+        }
+    });
+    lines.push("  Stop writes to the listed inputs before compilation, or fix the producer that omitted or contradicted the listed proof.");
+    // The failed snapshot remains useful as immutable retry evidence, but it can
+    // never serve a module. Release every live resource before its terminal
+    // verdict is retained in the cache.
+    disposeCachedTransform.disposeCachedTransform(validation.cached);
+    return new TtscUnstableGenerationError.TtscUnstableGenerationError(lines.join("\n"), validation);
+}
+
+exports.createUnstableGenerationError = createUnstableGenerationError;
+//# sourceMappingURL=createUnstableGenerationError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createUnstableGenerationError.js","sources":["../../../../src/core/transform/generation/createUnstableGenerationError.ts"],"sourcesContent":[null],"names":["disposeCachedTransform","TtscUnstableGenerationError"],"mappings":";;;;;;AAOA;AACA,SAAS,2BAA2B,CAClC,WAAmB,EACnB,KAAa,EAAA;IAEb,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;AACrD,IAAA,MAAM,OAAO,GACX,QAAQ,KAAK;AACX,UAAE;UACA,QAAQ,KAAK,IAAI;YACf,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,GAAG,CAAA,CAAE,CAAC;AACrC,YAAA,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ;AAC3B,cAAE;cACA,QAAQ;AAChB,IAAA,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D;AAEA;;;;;;;;;;;;;;;AAeG;SACa,6BAA6B,CAC3C,WAAmB,EACnB,QAAgD,EAChD,UAA0C,EAAA;AAE1C,IAAA,MAAM,KAAK,GAAG;QACZ,CAAA,8DAAA,EAAiE,QAAQ,CAAC,MAAM,CAAA,UAAA,CAAY;AAC5F,QAAA,CAAA,WAAA,EAAc,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA,CAAE;KAC5C;IACD,QAAQ,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,KAAI;QACnC,KAAK,CAAC,IAAI,CAAC,CAAA,UAAA,EAAa,KAAK,GAAG,CAAC,CAAA,CAAA,CAAG,CAAC;QACrC,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;AACjC,YAAA,KAAK,CAAC,IAAI,CAAC,2CAA2C,CAAC;QACzD;AACA,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,OAAO,EAAE;AACtC,YAAA,MAAM,KAAK,GACT,OAAO,CAAC,IAAI,KAAK;AACf,kBAAE;kBACA,CAAA,EAAA,EAAK,2BAA2B,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA,CAAE;AACnE,YAAA,MAAM,MAAM,GACV,OAAO,CAAC,MAAM,KAAK;AACjB,kBAAE;kBACA,CAAA,YAAA,EAAe,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA,CAAA,CAAG;AACtD,YAAA,KAAK,CAAC,IAAI,CAAC,CAAA,MAAA,EAAS,OAAO,CAAC,MAAM,CAAA,CAAA,EAAI,OAAO,CAAC,IAAI,CAAA,EAAG,KAAK,GAAG,MAAM,CAAA,CAAE,CAAC;QACxE;AACA,QAAA,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE;YAC1B,KAAK,CAAC,IAAI,CACR,CAAA,UAAA,EAAa,QAAQ,CAAC,OAAO,CAAA,+BAAA,CAAiC,CAC/D;QACH;AACF,IAAA,CAAC,CAAC;AACF,IAAA,KAAK,CAAC,IAAI,CACR,2HAA2H,CAC5H;;;;AAID,IAAAA,6CAAsB,CAAC,UAAU,CAAC,MAAM,CAAC;AACzC,IAAA,OAAO,IAAIC,uDAA2B,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;AACtE;;;;"}

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

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { disposeCachedTransform } from '../cache/disposeCachedTransform.mjs';
+import { TtscUnstableGenerationError } from '../errors/TtscUnstableGenerationError.mjs';
+
+/** Render one input without leaking source content or control characters. */
+function formatGenerationFailurePath(projectRoot, input) {
+    const absolute = path.resolve(input);
+    const relative = path.relative(projectRoot, absolute);
+    const display = relative === ""
+        ? "."
+        : relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)
+            ? relative
+            : absolute;
+    return JSON.stringify(display.split(path.sep).join("/"));
+}
+/**
+ * Build the terminal error shared by waiters of an unstable generation, with
+ * bounded per-attempt witnesses and a retained retry comparison baseline. Live
+ * generation fields detach and their cleanup is attempted before the error
+ * retains that data; failed native cleanup is not certified released. Producer
+ * details and native paths are JSON-escaped for safe diagnostics.
+ *
+ * @evidence contracts/common.md#principled-implementation Each attempted proof contributes its classified witnesses and omitted count, while absent retained entries remain an explicit incomplete proof; the validation baseline identifies the environment that can authorize retry.
+ * @evidence contracts/common.md#clear-and-simple-design Error rendering stays here, path attribution uses one private formatter and live generation disposal delegates to the shared lifecycle owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unstable proof is reported rather than converted into reusable output; dropped witnesses remain visible and diagnostic control characters cannot create fictitious lines.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes shared terminal error data from released live resources and explains bounded witnesses and escaped producer input.
+ * @evidence contracts/portability.md#os-neutral-implementation Native relative-path classification uses Node path semantics; slash rendering is only diagnostic presentation and does not change filesystem identity or project ownership.
+ * @evidence contracts/performance.md#efficient-algorithms Rendering visits each attempt and retained witness once, with native path processing and escaping driven by diagnostic text lengths; delegated disposal also closes the final attempt's retained watchers without rescanning source contents.
+ * @evidence contracts/performance.md#reuse-equivalent-work transformProject creates one terminal verdict for its failed attempt sequence, and cache waiters share that error instead of separately rerendering or recompiling the same unchanged environment.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The shared disposer detaches watcher/probe ownership and attempts each cleanup before the error retains comparison data. Failed native close/removal can leave underlying resources; the error does not acquire their handles or claim cleanup succeeded. Retained comparison/witness text has cache-owner lifetime and no byte bound from the witness-count cap.
+ */
+function createUnstableGenerationError(projectRoot, attempts, validation) {
+    const lines = [
+        `ttsc: could not capture a reusable transform generation after ${attempts.length} attempts.`,
+        `  project: ${JSON.stringify(projectRoot)}`,
+    ];
+    attempts.forEach((failures, index) => {
+        lines.push(`  attempt ${index + 1}:`);
+        if (failures.entries.length === 0) {
+            lines.push("    - project/generation-proof-incomplete");
+        }
+        for (const failure of failures.entries) {
+            const input = failure.path === undefined
+                ? ""
+                : `: ${formatGenerationFailurePath(projectRoot, failure.path)}`;
+            const detail = failure.detail === undefined
+                ? ""
+                : ` (producer: ${JSON.stringify(failure.detail)})`;
+            lines.push(`    - ${failure.domain}/${failure.kind}${input}${detail}`);
+        }
+        if (failures.omitted !== 0) {
+            lines.push(`    - ... ${failures.omitted} additional witness(es) omitted`);
+        }
+    });
+    lines.push("  Stop writes to the listed inputs before compilation, or fix the producer that omitted or contradicted the listed proof.");
+    // The failed snapshot remains useful as immutable retry evidence, but it can
+    // never serve a module. Release every live resource before its terminal
+    // verdict is retained in the cache.
+    disposeCachedTransform(validation.cached);
+    return new TtscUnstableGenerationError(lines.join("\n"), validation);
+}
+
+export { createUnstableGenerationError };
+//# sourceMappingURL=createUnstableGenerationError.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createUnstableGenerationError.mjs","sources":["../../../../src/core/transform/generation/createUnstableGenerationError.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;AACA,SAAS,2BAA2B,CAClC,WAAmB,EACnB,KAAa,EAAA;IAEb,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;AACrD,IAAA,MAAM,OAAO,GACX,QAAQ,KAAK;AACX,UAAE;UACA,QAAQ,KAAK,IAAI;YACf,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,GAAG,CAAA,CAAE,CAAC;AACrC,YAAA,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ;AAC3B,cAAE;cACA,QAAQ;AAChB,IAAA,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D;AAEA;;;;;;;;;;;;;;;AAeG;SACa,6BAA6B,CAC3C,WAAmB,EACnB,QAAgD,EAChD,UAA0C,EAAA;AAE1C,IAAA,MAAM,KAAK,GAAG;QACZ,CAAA,8DAAA,EAAiE,QAAQ,CAAC,MAAM,CAAA,UAAA,CAAY;AAC5F,QAAA,CAAA,WAAA,EAAc,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA,CAAE;KAC5C;IACD,QAAQ,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,KAAI;QACnC,KAAK,CAAC,IAAI,CAAC,CAAA,UAAA,EAAa,KAAK,GAAG,CAAC,CAAA,CAAA,CAAG,CAAC;QACrC,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;AACjC,YAAA,KAAK,CAAC,IAAI,CAAC,2CAA2C,CAAC;QACzD;AACA,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,OAAO,EAAE;AACtC,YAAA,MAAM,KAAK,GACT,OAAO,CAAC,IAAI,KAAK;AACf,kBAAE;kBACA,CAAA,EAAA,EAAK,2BAA2B,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA,CAAE;AACnE,YAAA,MAAM,MAAM,GACV,OAAO,CAAC,MAAM,KAAK;AACjB,kBAAE;kBACA,CAAA,YAAA,EAAe,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA,CAAA,CAAG;AACtD,YAAA,KAAK,CAAC,IAAI,CAAC,CAAA,MAAA,EAAS,OAAO,CAAC,MAAM,CAAA,CAAA,EAAI,OAAO,CAAC,IAAI,CAAA,EAAG,KAAK,GAAG,MAAM,CAAA,CAAE,CAAC;QACxE;AACA,QAAA,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE;YAC1B,KAAK,CAAC,IAAI,CACR,CAAA,UAAA,EAAa,QAAQ,CAAC,OAAO,CAAA,+BAAA,CAAiC,CAC/D;QACH;AACF,IAAA,CAAC,CAAC;AACF,IAAA,KAAK,CAAC,IAAI,CACR,2HAA2H,CAC5H;;;;AAID,IAAA,sBAAsB,CAAC,UAAU,CAAC,MAAM,CAAC;AACzC,IAAA,OAAO,IAAI,2BAA2B,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;AACtE;;;;"}

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

@@ -0,0 +1,45 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.cjs";
+/**
+ * Whether current observations refute a terminal proof failure's recorded
+ * environment.
+ *
+ * This is deliberately a confirmation test. Escaping probe exceptions retain
+ * the old verdict; represented unavailable fingerprints can differ from prior
+ * observations and trigger retry without proving a physical content change.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
+ *
+ * The delivered module's own text is checked on every delivery. The rest of the
+ * environment, the project walk and every recorded input outside it, is
+ * confirmed once per event-loop turn and shared by that turn's deliveries, and
+ * it is proven by metadata first, as live validation does: a file or input
+ * whose separable signature still matches carries its recorded state and is not
+ * read again (samchon/ttsc#1398). Separable means against a clock reference the
+ * confirmation mints itself before it reads, as a delivery does, so a write a
+ * clock rollback put into a recorded stamp's tick is read. The generation's own
+ * probe directory was released with it, so the reference is minted in the probe
+ * directory this process keeps (`refreshProcessClockReference`).
+ *
+ * The shared verdict remains until its scheduled setImmediate eviction runs.
+ * Writes after confirmation can therefore be missed by that window's later
+ * deliveries, apart from their independent delivered-text/disk check. Host
+ * delivery timing is not guaranteed here; lifecycle reset bypasses retained
+ * terminal state.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered-source divergence is checked against its disk baseline before sharing an environment verdict. Current project/failure or exact/tree state can refute the terminal baseline; represented unavailable observations may differ, while escaping exceptions return false. Neither false nor unavailable markers certify a reusable success.
+ * @evidence contracts/common.md#clear-and-simple-design The exported boundary handles per-delivery text and turn-shared coordination, while its private environment comparator owns walk and out-of-walk revalidation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A text-only upstream rewrite does not replace the compiler's disk baseline. Explicit failure fingerprints stay retry-comparison data rather than fabricated readable content; an escaping probe exception is not invented evidence of change.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain confirmation rather than successful-generation proof, current-turn sharing, clock separation and next-turn freshness limitations, with props and tags visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem identity and metadata separation use the supplied host operations and process clock reference; plugin tree state uses the same native build environment composition that keyed its binary.
+ * @evidence contracts/performance.md#efficient-algorithms Each delivery hashes supplied text and queries native identity, conditionally reading source bytes before any memo hit. A cold environment check refreshes clock proof, walks the project, compares file/directory/failure populations and validates all reached recorded inputs; metadata-separable matches avoid ordinary full fingerprints, while trees retain source/build scans. Costs include text/bytes, native access and delegated sorting/encoding, not just input count.
+ * @evidence contracts/performance.md#reuse-equivalent-work One verdict per validation object is shared until its setImmediate eviction callback runs. Stable validation contents and the same coherent host view are caller premises; delivered-text/disk checks remain outside sharing. This window can miss later same-window environment changes and does not establish success authority.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The WeakMap stores one boolean per reached validation object; each scheduled eviction callback temporarily keeps that object reachable until execution. There is no object-count cap or eviction deadline here. Baseline bytes belong to terminal/cache lifetime, while the shared process-clock owner controls probe acquisition and cleanup; this comparator does not acquire a generation watcher.
+ */
+export declare function failedGenerationEnvironmentChanged(validation: TtscFailedGenerationValidation, props: {
+    /** Native source path requested by this delivery. */
+    currentFile: string;
+    /** Host-supplied text checked separately from the turn-shared environment. */
+    currentSource: string;
+    /** Same host filesystem boundary that observed the cached generation. */
+    filesystem: TtscTransformFilesystemOperations;
+}): boolean;

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

@@ -0,0 +1,45 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.mjs";
+/**
+ * Whether current observations refute a terminal proof failure's recorded
+ * environment.
+ *
+ * This is deliberately a confirmation test. Escaping probe exceptions retain
+ * the old verdict; represented unavailable fingerprints can differ from prior
+ * observations and trigger retry without proving a physical content change.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
+ *
+ * The delivered module's own text is checked on every delivery. The rest of the
+ * environment, the project walk and every recorded input outside it, is
+ * confirmed once per event-loop turn and shared by that turn's deliveries, and
+ * it is proven by metadata first, as live validation does: a file or input
+ * whose separable signature still matches carries its recorded state and is not
+ * read again (samchon/ttsc#1398). Separable means against a clock reference the
+ * confirmation mints itself before it reads, as a delivery does, so a write a
+ * clock rollback put into a recorded stamp's tick is read. The generation's own
+ * probe directory was released with it, so the reference is minted in the probe
+ * directory this process keeps (`refreshProcessClockReference`).
+ *
+ * The shared verdict remains until its scheduled setImmediate eviction runs.
+ * Writes after confirmation can therefore be missed by that window's later
+ * deliveries, apart from their independent delivered-text/disk check. Host
+ * delivery timing is not guaranteed here; lifecycle reset bypasses retained
+ * terminal state.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered-source divergence is checked against its disk baseline before sharing an environment verdict. Current project/failure or exact/tree state can refute the terminal baseline; represented unavailable observations may differ, while escaping exceptions return false. Neither false nor unavailable markers certify a reusable success.
+ * @evidence contracts/common.md#clear-and-simple-design The exported boundary handles per-delivery text and turn-shared coordination, while its private environment comparator owns walk and out-of-walk revalidation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A text-only upstream rewrite does not replace the compiler's disk baseline. Explicit failure fingerprints stay retry-comparison data rather than fabricated readable content; an escaping probe exception is not invented evidence of change.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain confirmation rather than successful-generation proof, current-turn sharing, clock separation and next-turn freshness limitations, with props and tags visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem identity and metadata separation use the supplied host operations and process clock reference; plugin tree state uses the same native build environment composition that keyed its binary.
+ * @evidence contracts/performance.md#efficient-algorithms Each delivery hashes supplied text and queries native identity, conditionally reading source bytes before any memo hit. A cold environment check refreshes clock proof, walks the project, compares file/directory/failure populations and validates all reached recorded inputs; metadata-separable matches avoid ordinary full fingerprints, while trees retain source/build scans. Costs include text/bytes, native access and delegated sorting/encoding, not just input count.
+ * @evidence contracts/performance.md#reuse-equivalent-work One verdict per validation object is shared until its setImmediate eviction callback runs. Stable validation contents and the same coherent host view are caller premises; delivered-text/disk checks remain outside sharing. This window can miss later same-window environment changes and does not establish success authority.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The WeakMap stores one boolean per reached validation object; each scheduled eviction callback temporarily keeps that object reachable until execution. There is no object-count cap or eviction deadline here. Baseline bytes belong to terminal/cache lifetime, while the shared process-clock owner controls probe acquisition and cleanup; this comparator does not acquire a generation watcher.
+ */
+export declare function failedGenerationEnvironmentChanged(validation: TtscFailedGenerationValidation, props: {
+    /** Native source path requested by this delivery. */
+    currentFile: string;
+    /** Host-supplied text checked separately from the turn-shared environment. */
+    currentSource: string;
+    /** Same host filesystem boundary that observed the cached generation. */
+    filesystem: TtscTransformFilesystemOperations;
+}): boolean;

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

@@ -0,0 +1,45 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation";
+/**
+ * Whether current observations refute a terminal proof failure's recorded
+ * environment.
+ *
+ * This is deliberately a confirmation test. Escaping probe exceptions retain
+ * the old verdict; represented unavailable fingerprints can differ from prior
+ * observations and trigger retry without proving a physical content change.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
+ *
+ * The delivered module's own text is checked on every delivery. The rest of the
+ * environment, the project walk and every recorded input outside it, is
+ * confirmed once per event-loop turn and shared by that turn's deliveries, and
+ * it is proven by metadata first, as live validation does: a file or input
+ * whose separable signature still matches carries its recorded state and is not
+ * read again (samchon/ttsc#1398). Separable means against a clock reference the
+ * confirmation mints itself before it reads, as a delivery does, so a write a
+ * clock rollback put into a recorded stamp's tick is read. The generation's own
+ * probe directory was released with it, so the reference is minted in the probe
+ * directory this process keeps (`refreshProcessClockReference`).
+ *
+ * The shared verdict remains until its scheduled setImmediate eviction runs.
+ * Writes after confirmation can therefore be missed by that window's later
+ * deliveries, apart from their independent delivered-text/disk check. Host
+ * delivery timing is not guaranteed here; lifecycle reset bypasses retained
+ * terminal state.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered-source divergence is checked against its disk baseline before sharing an environment verdict. Current project/failure or exact/tree state can refute the terminal baseline; represented unavailable observations may differ, while escaping exceptions return false. Neither false nor unavailable markers certify a reusable success.
+ * @evidence contracts/common.md#clear-and-simple-design The exported boundary handles per-delivery text and turn-shared coordination, while its private environment comparator owns walk and out-of-walk revalidation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A text-only upstream rewrite does not replace the compiler's disk baseline. Explicit failure fingerprints stay retry-comparison data rather than fabricated readable content; an escaping probe exception is not invented evidence of change.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain confirmation rather than successful-generation proof, current-turn sharing, clock separation and next-turn freshness limitations, with props and tags visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem identity and metadata separation use the supplied host operations and process clock reference; plugin tree state uses the same native build environment composition that keyed its binary.
+ * @evidence contracts/performance.md#efficient-algorithms Each delivery hashes supplied text and queries native identity, conditionally reading source bytes before any memo hit. A cold environment check refreshes clock proof, walks the project, compares file/directory/failure populations and validates all reached recorded inputs; metadata-separable matches avoid ordinary full fingerprints, while trees retain source/build scans. Costs include text/bytes, native access and delegated sorting/encoding, not just input count.
+ * @evidence contracts/performance.md#reuse-equivalent-work One verdict per validation object is shared until its setImmediate eviction callback runs. Stable validation contents and the same coherent host view are caller premises; delivered-text/disk checks remain outside sharing. This window can miss later same-window environment changes and does not establish success authority.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The WeakMap stores one boolean per reached validation object; each scheduled eviction callback temporarily keeps that object reachable until execution. There is no object-count cap or eviction deadline here. Baseline bytes belong to terminal/cache lifetime, while the shared process-clock owner controls probe acquisition and cleanup; this comparator does not acquire a generation watcher.
+ */
+export declare function failedGenerationEnvironmentChanged(validation: TtscFailedGenerationValidation, props: {
+    /** Native source path requested by this delivery. */
+    currentFile: string;
+    /** Host-supplied text checked separately from the turn-shared environment. */
+    currentSource: string;
+    /** Same host filesystem boundary that observed the cached generation. */
+    filesystem: TtscTransformFilesystemOperations;
+}): boolean;

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

@@ -0,0 +1,128 @@
+'use strict';
+
+var pluginSource = require('ttsc/plugin-source');
+var refreshProcessClockReference = require('../clock/refreshProcessClockReference.js');
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var inputMetadataEvidence = require('../inputs/inputMetadataEvidence.js');
+var pluginSourceHolds = require('../inputs/pluginSourceHolds.js');
+var pluginSourceState = require('../inputs/pluginSourceState.js');
+var preparePluginBuildEnvironments = require('../inputs/preparePluginBuildEnvironments.js');
+var collectProjectInputSnapshot = require('../project/collectProjectInputSnapshot.js');
+var hashText = require('../utils/hashText.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+var sameHashes = require('../validation/sameHashes.js');
+var sameProjectDirectories = require('../validation/sameProjectDirectories.js');
+var walkSnapshotComplete = require('../validation/walkSnapshotComplete.js');
+var TERMINAL_ENVIRONMENT_VERDICTS = require('./TERMINAL_ENVIRONMENT_VERDICTS.js');
+var failedGenerationInputState = require('./failedGenerationInputState.js');
+var projectWalkFailureFingerprint = require('./projectWalkFailureFingerprint.js');
+
+/**
+ * Whether current observations refute a terminal proof failure's recorded
+ * environment.
+ *
+ * This is deliberately a confirmation test. Escaping probe exceptions retain
+ * the old verdict; represented unavailable fingerprints can differ from prior
+ * observations and trigger retry without proving a physical content change.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
+ *
+ * The delivered module's own text is checked on every delivery. The rest of the
+ * environment, the project walk and every recorded input outside it, is
+ * confirmed once per event-loop turn and shared by that turn's deliveries, and
+ * it is proven by metadata first, as live validation does: a file or input
+ * whose separable signature still matches carries its recorded state and is not
+ * read again (samchon/ttsc#1398). Separable means against a clock reference the
+ * confirmation mints itself before it reads, as a delivery does, so a write a
+ * clock rollback put into a recorded stamp's tick is read. The generation's own
+ * probe directory was released with it, so the reference is minted in the probe
+ * directory this process keeps (`refreshProcessClockReference`).
+ *
+ * The shared verdict remains until its scheduled setImmediate eviction runs.
+ * Writes after confirmation can therefore be missed by that window's later
+ * deliveries, apart from their independent delivered-text/disk check. Host
+ * delivery timing is not guaranteed here; lifecycle reset bypasses retained
+ * terminal state.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered-source divergence is checked against its disk baseline before sharing an environment verdict. Current project/failure or exact/tree state can refute the terminal baseline; represented unavailable observations may differ, while escaping exceptions return false. Neither false nor unavailable markers certify a reusable success.
+ * @evidence contracts/common.md#clear-and-simple-design The exported boundary handles per-delivery text and turn-shared coordination, while its private environment comparator owns walk and out-of-walk revalidation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A text-only upstream rewrite does not replace the compiler's disk baseline. Explicit failure fingerprints stay retry-comparison data rather than fabricated readable content; an escaping probe exception is not invented evidence of change.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain confirmation rather than successful-generation proof, current-turn sharing, clock separation and next-turn freshness limitations, with props and tags visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem identity and metadata separation use the supplied host operations and process clock reference; plugin tree state uses the same native build environment composition that keyed its binary.
+ * @evidence contracts/performance.md#efficient-algorithms Each delivery hashes supplied text and queries native identity, conditionally reading source bytes before any memo hit. A cold environment check refreshes clock proof, walks the project, compares file/directory/failure populations and validates all reached recorded inputs; metadata-separable matches avoid ordinary full fingerprints, while trees retain source/build scans. Costs include text/bytes, native access and delegated sorting/encoding, not just input count.
+ * @evidence contracts/performance.md#reuse-equivalent-work One verdict per validation object is shared until its setImmediate eviction callback runs. Stable validation contents and the same coherent host view are caller premises; delivered-text/disk checks remain outside sharing. This window can miss later same-window environment changes and does not establish success authority.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The WeakMap stores one boolean per reached validation object; each scheduled eviction callback temporarily keeps that object reachable until execution. There is no object-count cap or eviction deadline here. Baseline bytes belong to terminal/cache lifetime, while the shared process-clock owner controls probe acquisition and cleanup; this comparator does not acquire a generation watcher.
+ */
+function failedGenerationEnvironmentChanged(validation, props) {
+    try {
+        const identities = envelopeDerivation.envelopeDerivation(validation.cached).identityContext;
+        const currentSourceHash = hashText.hashText(props.currentSource);
+        const expectedSourceHash = validation.cached.sourceHashes?.[pathIdentityKey.pathIdentityKey(props.currentFile, identities)];
+        // A delivered text that differs from the file changes nothing while the
+        // disk still holds the bytes the compile read (samchon/ttsc#1394).
+        if (expectedSourceHash !== undefined &&
+            expectedSourceHash !== currentSourceHash &&
+            hostInputStateHash.hostInputStateHash(props.currentFile, props.filesystem) !==
+                expectedSourceHash) {
+            return true;
+        }
+        const shared = TERMINAL_ENVIRONMENT_VERDICTS.TERMINAL_ENVIRONMENT_VERDICTS.get(validation);
+        if (shared !== undefined)
+            return shared;
+        const verdict = environmentChanged(validation, props.filesystem);
+        TERMINAL_ENVIRONMENT_VERDICTS.TERMINAL_ENVIRONMENT_VERDICTS.set(validation, verdict);
+        setImmediate(() => TERMINAL_ENVIRONMENT_VERDICTS.TERMINAL_ENVIRONMENT_VERDICTS.delete(validation));
+        return verdict;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Confirm the project walk and every recorded input outside it. A plugin tree
+ * always validates its full source/build state before ordinary-path metadata
+ * reuse is considered, because parent metadata cannot prove descendant state.
+ */
+function environmentChanged(validation, filesystem) {
+    refreshProcessClockReference.refreshProcessClockReference(validation.cached.projectRoot, filesystem);
+    const identities = envelopeDerivation.envelopeDerivation(validation.cached).identityContext;
+    const current = collectProjectInputSnapshot.collectProjectInputSnapshot(validation.cached.projectRoot, identities, filesystem, {
+        hashes: validation.projectInputHashes,
+        signatures: validation.cached.inputSignatures ?? {},
+    }, { policy: validation.cached.membershipPolicy });
+    if (validation.projectWalkComplete !==
+        walkSnapshotComplete.walkSnapshotComplete(current, validation.declaredInputs) ||
+        validation.projectWalkFailures !==
+            projectWalkFailureFingerprint.projectWalkFailureFingerprint(current, validation.declaredInputs, validation.cached.projectRoot, identities) ||
+        !sameHashes.sameHashes(validation.projectInputHashes, current.hashes, validation.declaredInputs) ||
+        !sameProjectDirectories.sameProjectDirectories(validation.cached.projectDirectories ?? [], current.projectDirectories)) {
+        return true;
+    }
+    for (const [input, recorded] of validation.inputStates) {
+        if (recorded.tree) {
+            // A plugin source that could not be read then moved once it can be.
+            // The async delivery owner prepares native authority before confirmation.
+            const prepared = preparePluginBuildEnvironments.usesPreparedPluginBuildEnvironments(validation.cached.result)
+                ? { environment: pluginSource.PluginBuildEnvironmentReadings.cached(input) }
+                : undefined;
+            if (recorded.state === MISSING_INPUT_STATE.MISSING_INPUT_STATE
+                ? pluginSourceState.pluginSourceState(input, prepared) !== null
+                : !pluginSourceHolds.pluginSourceHolds(input, recorded.state, filesystem, prepared))
+                return true;
+            continue;
+        }
+        const evidence = inputMetadataEvidence.inputMetadataEvidence(input, filesystem);
+        if (recorded.signature !== undefined &&
+            evidence?.separable === true &&
+            evidence.signature === recorded.signature) {
+            continue;
+        }
+        if (failedGenerationInputState.failedGenerationInputState(input, filesystem) !== recorded.state)
+            return true;
+    }
+    return false;
+}
+
+exports.failedGenerationEnvironmentChanged = failedGenerationEnvironmentChanged;
+//# sourceMappingURL=failedGenerationEnvironmentChanged.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"failedGenerationEnvironmentChanged.js","sources":["../../../../src/core/transform/generation/failedGenerationEnvironmentChanged.ts"],"sourcesContent":[null],"names":["envelopeDerivation","hashText","pathIdentityKey","hostInputStateHash","TERMINAL_ENVIRONMENT_VERDICTS","refreshProcessClockReference","collectProjectInputSnapshot","walkSnapshotComplete","projectWalkFailureFingerprint","sameHashes","sameProjectDirectories","usesPreparedPluginBuildEnvironments","PluginBuildEnvironmentReadings","MISSING_INPUT_STATE","pluginSourceState","pluginSourceHolds","inputMetadataEvidence","failedGenerationInputState"],"mappings":"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"}

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

@@ -0,0 +1,126 @@
+import { PluginBuildEnvironmentReadings } from 'ttsc/plugin-source';
+import { refreshProcessClockReference } from '../clock/refreshProcessClockReference.mjs';
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { inputMetadataEvidence } from '../inputs/inputMetadataEvidence.mjs';
+import { pluginSourceHolds } from '../inputs/pluginSourceHolds.mjs';
+import { pluginSourceState } from '../inputs/pluginSourceState.mjs';
+import { usesPreparedPluginBuildEnvironments } from '../inputs/preparePluginBuildEnvironments.mjs';
+import { collectProjectInputSnapshot } from '../project/collectProjectInputSnapshot.mjs';
+import { hashText } from '../utils/hashText.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+import { sameHashes } from '../validation/sameHashes.mjs';
+import { sameProjectDirectories } from '../validation/sameProjectDirectories.mjs';
+import { walkSnapshotComplete } from '../validation/walkSnapshotComplete.mjs';
+import { TERMINAL_ENVIRONMENT_VERDICTS } from './TERMINAL_ENVIRONMENT_VERDICTS.mjs';
+import { failedGenerationInputState } from './failedGenerationInputState.mjs';
+import { projectWalkFailureFingerprint } from './projectWalkFailureFingerprint.mjs';
+
+/**
+ * Whether current observations refute a terminal proof failure's recorded
+ * environment.
+ *
+ * This is deliberately a confirmation test. Escaping probe exceptions retain
+ * the old verdict; represented unavailable fingerprints can differ from prior
+ * observations and trigger retry without proving a physical content change.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
+ *
+ * The delivered module's own text is checked on every delivery. The rest of the
+ * environment, the project walk and every recorded input outside it, is
+ * confirmed once per event-loop turn and shared by that turn's deliveries, and
+ * it is proven by metadata first, as live validation does: a file or input
+ * whose separable signature still matches carries its recorded state and is not
+ * read again (samchon/ttsc#1398). Separable means against a clock reference the
+ * confirmation mints itself before it reads, as a delivery does, so a write a
+ * clock rollback put into a recorded stamp's tick is read. The generation's own
+ * probe directory was released with it, so the reference is minted in the probe
+ * directory this process keeps (`refreshProcessClockReference`).
+ *
+ * The shared verdict remains until its scheduled setImmediate eviction runs.
+ * Writes after confirmation can therefore be missed by that window's later
+ * deliveries, apart from their independent delivered-text/disk check. Host
+ * delivery timing is not guaranteed here; lifecycle reset bypasses retained
+ * terminal state.
+ *
+ * @evidence contracts/common.md#principled-implementation Delivered-source divergence is checked against its disk baseline before sharing an environment verdict. Current project/failure or exact/tree state can refute the terminal baseline; represented unavailable observations may differ, while escaping exceptions return false. Neither false nor unavailable markers certify a reusable success.
+ * @evidence contracts/common.md#clear-and-simple-design The exported boundary handles per-delivery text and turn-shared coordination, while its private environment comparator owns walk and out-of-walk revalidation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A text-only upstream rewrite does not replace the compiler's disk baseline. Explicit failure fingerprints stay retry-comparison data rather than fabricated readable content; an escaping probe exception is not invented evidence of change.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain confirmation rather than successful-generation proof, current-turn sharing, clock separation and next-turn freshness limitations, with props and tags visibly separated.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem identity and metadata separation use the supplied host operations and process clock reference; plugin tree state uses the same native build environment composition that keyed its binary.
+ * @evidence contracts/performance.md#efficient-algorithms Each delivery hashes supplied text and queries native identity, conditionally reading source bytes before any memo hit. A cold environment check refreshes clock proof, walks the project, compares file/directory/failure populations and validates all reached recorded inputs; metadata-separable matches avoid ordinary full fingerprints, while trees retain source/build scans. Costs include text/bytes, native access and delegated sorting/encoding, not just input count.
+ * @evidence contracts/performance.md#reuse-equivalent-work One verdict per validation object is shared until its setImmediate eviction callback runs. Stable validation contents and the same coherent host view are caller premises; delivered-text/disk checks remain outside sharing. This window can miss later same-window environment changes and does not establish success authority.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The WeakMap stores one boolean per reached validation object; each scheduled eviction callback temporarily keeps that object reachable until execution. There is no object-count cap or eviction deadline here. Baseline bytes belong to terminal/cache lifetime, while the shared process-clock owner controls probe acquisition and cleanup; this comparator does not acquire a generation watcher.
+ */
+function failedGenerationEnvironmentChanged(validation, props) {
+    try {
+        const identities = envelopeDerivation(validation.cached).identityContext;
+        const currentSourceHash = hashText(props.currentSource);
+        const expectedSourceHash = validation.cached.sourceHashes?.[pathIdentityKey(props.currentFile, identities)];
+        // A delivered text that differs from the file changes nothing while the
+        // disk still holds the bytes the compile read (samchon/ttsc#1394).
+        if (expectedSourceHash !== undefined &&
+            expectedSourceHash !== currentSourceHash &&
+            hostInputStateHash(props.currentFile, props.filesystem) !==
+                expectedSourceHash) {
+            return true;
+        }
+        const shared = TERMINAL_ENVIRONMENT_VERDICTS.get(validation);
+        if (shared !== undefined)
+            return shared;
+        const verdict = environmentChanged(validation, props.filesystem);
+        TERMINAL_ENVIRONMENT_VERDICTS.set(validation, verdict);
+        setImmediate(() => TERMINAL_ENVIRONMENT_VERDICTS.delete(validation));
+        return verdict;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Confirm the project walk and every recorded input outside it. A plugin tree
+ * always validates its full source/build state before ordinary-path metadata
+ * reuse is considered, because parent metadata cannot prove descendant state.
+ */
+function environmentChanged(validation, filesystem) {
+    refreshProcessClockReference(validation.cached.projectRoot, filesystem);
+    const identities = envelopeDerivation(validation.cached).identityContext;
+    const current = collectProjectInputSnapshot(validation.cached.projectRoot, identities, filesystem, {
+        hashes: validation.projectInputHashes,
+        signatures: validation.cached.inputSignatures ?? {},
+    }, { policy: validation.cached.membershipPolicy });
+    if (validation.projectWalkComplete !==
+        walkSnapshotComplete(current, validation.declaredInputs) ||
+        validation.projectWalkFailures !==
+            projectWalkFailureFingerprint(current, validation.declaredInputs, validation.cached.projectRoot, identities) ||
+        !sameHashes(validation.projectInputHashes, current.hashes, validation.declaredInputs) ||
+        !sameProjectDirectories(validation.cached.projectDirectories ?? [], current.projectDirectories)) {
+        return true;
+    }
+    for (const [input, recorded] of validation.inputStates) {
+        if (recorded.tree) {
+            // A plugin source that could not be read then moved once it can be.
+            // The async delivery owner prepares native authority before confirmation.
+            const prepared = usesPreparedPluginBuildEnvironments(validation.cached.result)
+                ? { environment: PluginBuildEnvironmentReadings.cached(input) }
+                : undefined;
+            if (recorded.state === MISSING_INPUT_STATE
+                ? pluginSourceState(input, prepared) !== null
+                : !pluginSourceHolds(input, recorded.state, filesystem, prepared))
+                return true;
+            continue;
+        }
+        const evidence = inputMetadataEvidence(input, filesystem);
+        if (recorded.signature !== undefined &&
+            evidence?.separable === true &&
+            evidence.signature === recorded.signature) {
+            continue;
+        }
+        if (failedGenerationInputState(input, filesystem) !== recorded.state)
+            return true;
+    }
+    return false;
+}
+
+export { failedGenerationEnvironmentChanged };
+//# sourceMappingURL=failedGenerationEnvironmentChanged.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"failedGenerationEnvironmentChanged.mjs","sources":["../../../../src/core/transform/generation/failedGenerationEnvironmentChanged.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

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

@@ -0,0 +1,17 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Digest one exact out-of-walk path's metadata, content state, physical target
+ * and directory listing. Failed directory observation is distinct from a path
+ * that is not a directory; this is a retry-change fingerprint, not a success
+ * proof of an unreadable input.
+ *
+ * @evidence contracts/common.md#principled-implementation Metadata, host state, realpath and sorted entry-kind observations jointly represent exact-path changes; missing/unavailable states remain explicit in the serialized digest.
+ * @evidence contracts/common.md#clear-and-simple-design Existing input helpers own metadata/content/identity reads; this operation composes them with directory membership into one compact terminal comparison value.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures cannot equal an invented valid directory state, and a retained failure fingerprint does not certify unreadable compiler input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies fingerprint components, failed-directory distinctions and the difference between retry comparison and reusable-generation proof.
+ * @evidence contracts/portability.md#os-neutral-implementation All native observations use the injected filesystem boundary and host helpers; directory entry classifications come from actual Dirent capabilities rather than suffix or OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Following kind, metadata, content and realpath observations each retain native path/access costs; helpers can reread metadata and resolve ancestors rather than making a fixed observation count a time bound. A directory's N entries are materialized, their name/kind text sorted and joined before hashing, with comparison/encoding costs driven by text bytes and O(N) listing/frame storage. Content hashing additionally reads available bytes; sorting removes enumeration-order effects, not observation failures.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh observation fingerprint establishes a current comparison value; terminal environment validation owns metadata-first reuse and turn-shared verdicts.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a digest transfers to the caller; this operation owns no historical input-state cache, native handle or watcher lifecycle.
+ */
+export declare function failedGenerationInputState(input: string, filesystem: TtscTransformFilesystemOperations): string;

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

@@ -0,0 +1,17 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Digest one exact out-of-walk path's metadata, content state, physical target
+ * and directory listing. Failed directory observation is distinct from a path
+ * that is not a directory; this is a retry-change fingerprint, not a success
+ * proof of an unreadable input.
+ *
+ * @evidence contracts/common.md#principled-implementation Metadata, host state, realpath and sorted entry-kind observations jointly represent exact-path changes; missing/unavailable states remain explicit in the serialized digest.
+ * @evidence contracts/common.md#clear-and-simple-design Existing input helpers own metadata/content/identity reads; this operation composes them with directory membership into one compact terminal comparison value.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures cannot equal an invented valid directory state, and a retained failure fingerprint does not certify unreadable compiler input.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies fingerprint components, failed-directory distinctions and the difference between retry comparison and reusable-generation proof.
+ * @evidence contracts/portability.md#os-neutral-implementation All native observations use the injected filesystem boundary and host helpers; directory entry classifications come from actual Dirent capabilities rather than suffix or OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Following kind, metadata, content and realpath observations each retain native path/access costs; helpers can reread metadata and resolve ancestors rather than making a fixed observation count a time bound. A directory's N entries are materialized, their name/kind text sorted and joined before hashing, with comparison/encoding costs driven by text bytes and O(N) listing/frame storage. Content hashing additionally reads available bytes; sorting removes enumeration-order effects, not observation failures.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh observation fingerprint establishes a current comparison value; terminal environment validation owns metadata-first reuse and turn-shared verdicts.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a digest transfers to the caller; this operation owns no historical input-state cache, native handle or watcher lifecycle.
+ */
+export declare function failedGenerationInputState(input: string, filesystem: TtscTransformFilesystemOperations): string;