@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/cache/replaysTerminalGeneration.mjs

@@ -0,0 +1,56 @@
+import { TtscPassVerdictError } from '../errors/TtscPassVerdictError.mjs';
+import { TtscUnstableGenerationError } from '../errors/TtscUnstableGenerationError.mjs';
+import { failedGenerationEnvironmentChanged } from '../generation/failedGenerationEnvironmentChanged.mjs';
+
+/**
+ * Whether a terminal verdict still answers for this delivery.
+ *
+ * A pass verdict is replayed without re-probing anything inside the pass that
+ * produced it: the pass settles every delivery against the state it started
+ * from, so re-walking the project once per module would spend exactly the cost
+ * this gate exists to remove.
+ *
+ * An unstable generation has a recorded environment, and it is confirmed
+ * against the disk on every delivery (`failedGenerationEnvironmentChanged`,
+ * which shares one project walk per event-loop turn). The pass does not cache
+ * that answer. Inside a pass, only a verdict captured in that pass is replayed;
+ * one captured in an earlier pass grants a fresh attempt.
+ *
+ * Across passes the two kinds part company. A pass verdict is dropped, because
+ * a new pass is the first boundary at which the host itself claims something
+ * may have changed, and the compile it stood for was never proven against a
+ * recorded environment. An unstable generation was, so it keeps its own rule:
+ * one fresh attempt per pass, and otherwise replayed until that recorded
+ * environment provably moves.
+ *
+ * @evidence contracts/common.md#principled-implementation A pass verdict replays only in its own epoch; an unstable-generation verdict requires its recorded environment to remain unchanged and permits a new attempt in a new pass.
+ * @evidence contracts/common.md#clear-and-simple-design Explicit error-kind branches preserve their different evidence instead of applying one blanket retry policy to every terminal error.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown error kinds are not authorized for replay, and epoch equality cannot replace an unstable generation's environment proof.
+ * @evidence contracts/common.md#meaningful-documentation The paragraphs and branch comments explain why pass failures and recorded instability have different replay boundaries.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the verdict objects belong to the cache entry.
+ * @evidence contracts/performance.md#efficient-algorithms Error-kind and epoch guards avoid unnecessary re-probing; unstable verdicts delegate delivered-text hashing and a turn-shared project/exact-input comparison whose work follows text bytes, project population and changed input states.
+ * @evidence contracts/performance.md#reuse-equivalent-work It decides whether a failed verdict is replayed instead of repeating a whole-project compile: a pass verdict by its epoch, an unstable one by its recorded environment.
+ * @evidence contracts/portability.md#os-neutral-implementation Unstable replay uses the supplied native source path and filesystem operations through the captured identity and environment comparator; pass-only replay requires no filesystem observation.
+ */
+function replaysTerminalGeneration(terminal, epoch, props) {
+    if (terminal instanceof TtscPassVerdictError) {
+        // A pass verdict has no recorded environment to re-confirm against, so the
+        // pass that produced it is its whole scope.
+        return epoch !== undefined && terminal.epoch === epoch;
+    }
+    if (!(terminal instanceof TtscUnstableGenerationError)) {
+        return false;
+    }
+    // An unstable generation does have one, and confirming it per delivery is the
+    // behaviour its own contract describes, so the pass does not cache that
+    // answer. A new pass still grants the fresh attempt the per-pass cache clear
+    // used to give it.
+    if (epoch !== undefined &&
+        terminal.validation.cached.deliveryEpoch !== epoch) {
+        return false;
+    }
+    return !failedGenerationEnvironmentChanged(terminal.validation, props);
+}
+
+export { replaysTerminalGeneration };
+//# sourceMappingURL=replaysTerminalGeneration.mjs.map

package/lib/core/transform/cache/replaysTerminalGeneration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaysTerminalGeneration.mjs","sources":["../../../../src/core/transform/cache/replaysTerminalGeneration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;SACa,yBAAyB,CACvC,QAAqC,EACrC,KAAyB,EACzB,KAIC,EAAA;AAED,IAAA,IAAI,QAAQ,YAAY,oBAAoB,EAAE;;;QAG5C,OAAO,KAAK,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,KAAK,KAAK;IACxD;AACA,IAAA,IAAI,EAAE,QAAQ,YAAY,2BAA2B,CAAC,EAAE;AACtD,QAAA,OAAO,KAAK;IACd;;;;;IAKA,IACE,KAAK,KAAK,SAAS;QACnB,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,aAAa,KAAK,KAAK,EAClD;AACA,QAAA,OAAO,KAAK;IACd;IACA,OAAO,CAAC,kCAAkC,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;AACxE;;;;"}

package/lib/core/transform/cache/resetTtscTransformCache.d.cts

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Discard every generation, schedule its resource cleanup and return the cache
+ * to persistent validation mode.
+ *
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * `beginTtscTransformBuild`: a pass ending is not a reason to throw a proven
+ * compile away, while a session ending is.
+ *
+ * @evidence contracts/common.md#principled-implementation Reset immediately removes cached promises and the epoch, while fulfilled pending generations subsequently attempt their owned resource cleanup.
+ * @evidence contracts/common.md#clear-and-simple-design The exported lifecycle boundary delegates entry cleanup to one helper and separately removes the delivery-pass declaration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reset is an explicit ownership boundary, not a per-module recompilation workaround or patched Promise behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why session reset differs from opening the next delivery pass.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Withdrawal snapshots N promises then schedules N reactions with O(N)
+ *   temporary references; epoch deletion is fixed work. Fulfilled reactions
+ *   additionally perform generation-owned watcher/probe cleanup, without
+ *   serially awaiting compiles or scanning project files here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The explicit reset boundary preserves reuse across ordinary pass openings and shares the standard generation disposer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Entries and epoch are removed immediately, unlike volatile withdrawal.
+ *   Fulfilled generations transfer their handles/probes to disposal attempts;
+ *   pending compiles have no cancellation deadline and failed native cleanup
+ *   can leave underlying resources. No new lifecycle state is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Reset delegates cleanup to each generation's actual native close and probe
+ *   owners, preserving their observing capability rather than assuming every
+ *   platform releases resources identically. Epoch deletion is separate scalar
+ *   lifecycle state and does not normalize filesystem keys.
+ */
+export declare function resetTtscTransformCache(
+/** Cache ending its generation and declared delivery-pass ownership. */
+cache: TtscTransformCache): void;

package/lib/core/transform/cache/resetTtscTransformCache.d.mts

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Discard every generation, schedule its resource cleanup and return the cache
+ * to persistent validation mode.
+ *
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * `beginTtscTransformBuild`: a pass ending is not a reason to throw a proven
+ * compile away, while a session ending is.
+ *
+ * @evidence contracts/common.md#principled-implementation Reset immediately removes cached promises and the epoch, while fulfilled pending generations subsequently attempt their owned resource cleanup.
+ * @evidence contracts/common.md#clear-and-simple-design The exported lifecycle boundary delegates entry cleanup to one helper and separately removes the delivery-pass declaration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reset is an explicit ownership boundary, not a per-module recompilation workaround or patched Promise behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why session reset differs from opening the next delivery pass.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Withdrawal snapshots N promises then schedules N reactions with O(N)
+ *   temporary references; epoch deletion is fixed work. Fulfilled reactions
+ *   additionally perform generation-owned watcher/probe cleanup, without
+ *   serially awaiting compiles or scanning project files here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The explicit reset boundary preserves reuse across ordinary pass openings and shares the standard generation disposer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Entries and epoch are removed immediately, unlike volatile withdrawal.
+ *   Fulfilled generations transfer their handles/probes to disposal attempts;
+ *   pending compiles have no cancellation deadline and failed native cleanup
+ *   can leave underlying resources. No new lifecycle state is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Reset delegates cleanup to each generation's actual native close and probe
+ *   owners, preserving their observing capability rather than assuming every
+ *   platform releases resources identically. Epoch deletion is separate scalar
+ *   lifecycle state and does not normalize filesystem keys.
+ */
+export declare function resetTtscTransformCache(
+/** Cache ending its generation and declared delivery-pass ownership. */
+cache: TtscTransformCache): void;

package/lib/core/transform/cache/resetTtscTransformCache.d.ts

@@ -0,0 +1,33 @@
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Discard every generation, schedule its resource cleanup and return the cache
+ * to persistent validation mode.
+ *
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * `beginTtscTransformBuild`: a pass ending is not a reason to throw a proven
+ * compile away, while a session ending is.
+ *
+ * @evidence contracts/common.md#principled-implementation Reset immediately removes cached promises and the epoch, while fulfilled pending generations subsequently attempt their owned resource cleanup.
+ * @evidence contracts/common.md#clear-and-simple-design The exported lifecycle boundary delegates entry cleanup to one helper and separately removes the delivery-pass declaration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reset is an explicit ownership boundary, not a per-module recompilation workaround or patched Promise behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why session reset differs from opening the next delivery pass.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Withdrawal snapshots N promises then schedules N reactions with O(N)
+ *   temporary references; epoch deletion is fixed work. Fulfilled reactions
+ *   additionally perform generation-owned watcher/probe cleanup, without
+ *   serially awaiting compiles or scanning project files here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The explicit reset boundary preserves reuse across ordinary pass openings and shares the standard generation disposer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Entries and epoch are removed immediately, unlike volatile withdrawal.
+ *   Fulfilled generations transfer their handles/probes to disposal attempts;
+ *   pending compiles have no cancellation deadline and failed native cleanup
+ *   can leave underlying resources. No new lifecycle state is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Reset delegates cleanup to each generation's actual native close and probe
+ *   owners, preserving their observing capability rather than assuming every
+ *   platform releases resources identically. Epoch deletion is separate scalar
+ *   lifecycle state and does not normalize filesystem keys.
+ */
+export declare function resetTtscTransformCache(
+/** Cache ending its generation and declared delivery-pass ownership. */
+cache: TtscTransformCache): void;

package/lib/core/transform/cache/resetTtscTransformCache.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var TRANSFORM_CACHE_EPOCHS = require('./TRANSFORM_CACHE_EPOCHS.js');
+var withdrawTtscTransformGenerations = require('./withdrawTtscTransformGenerations.js');
+
+/**
+ * Discard every generation, schedule its resource cleanup and return the cache
+ * to persistent validation mode.
+ *
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * `beginTtscTransformBuild`: a pass ending is not a reason to throw a proven
+ * compile away, while a session ending is.
+ *
+ * @evidence contracts/common.md#principled-implementation Reset immediately removes cached promises and the epoch, while fulfilled pending generations subsequently attempt their owned resource cleanup.
+ * @evidence contracts/common.md#clear-and-simple-design The exported lifecycle boundary delegates entry cleanup to one helper and separately removes the delivery-pass declaration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reset is an explicit ownership boundary, not a per-module recompilation workaround or patched Promise behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why session reset differs from opening the next delivery pass.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Withdrawal snapshots N promises then schedules N reactions with O(N)
+ *   temporary references; epoch deletion is fixed work. Fulfilled reactions
+ *   additionally perform generation-owned watcher/probe cleanup, without
+ *   serially awaiting compiles or scanning project files here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The explicit reset boundary preserves reuse across ordinary pass openings and shares the standard generation disposer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Entries and epoch are removed immediately, unlike volatile withdrawal.
+ *   Fulfilled generations transfer their handles/probes to disposal attempts;
+ *   pending compiles have no cancellation deadline and failed native cleanup
+ *   can leave underlying resources. No new lifecycle state is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Reset delegates cleanup to each generation's actual native close and probe
+ *   owners, preserving their observing capability rather than assuming every
+ *   platform releases resources identically. Epoch deletion is separate scalar
+ *   lifecycle state and does not normalize filesystem keys.
+ */
+function resetTtscTransformCache(
+/** Cache ending its generation and declared delivery-pass ownership. */
+cache) {
+    withdrawTtscTransformGenerations.withdrawTtscTransformGenerations(cache);
+    TRANSFORM_CACHE_EPOCHS.TRANSFORM_CACHE_EPOCHS.delete(cache);
+}
+
+exports.resetTtscTransformCache = resetTtscTransformCache;
+//# sourceMappingURL=resetTtscTransformCache.js.map

package/lib/core/transform/cache/resetTtscTransformCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resetTtscTransformCache.js","sources":["../../../../src/core/transform/cache/resetTtscTransformCache.ts"],"sourcesContent":[null],"names":["withdrawTtscTransformGenerations","TRANSFORM_CACHE_EPOCHS"],"mappings":";;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,uBAAuB;AACrC;AACA,KAAyB,EAAA;IAEzBA,iEAAgC,CAAC,KAAK,CAAC;AACvC,IAAAC,6CAAsB,CAAC,MAAM,CAAC,KAAK,CAAC;AACtC;;;;"}

package/lib/core/transform/cache/resetTtscTransformCache.mjs

@@ -0,0 +1,41 @@
+import { TRANSFORM_CACHE_EPOCHS } from './TRANSFORM_CACHE_EPOCHS.mjs';
+import { withdrawTtscTransformGenerations } from './withdrawTtscTransformGenerations.mjs';
+
+/**
+ * Discard every generation, schedule its resource cleanup and return the cache
+ * to persistent validation mode.
+ *
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * `beginTtscTransformBuild`: a pass ending is not a reason to throw a proven
+ * compile away, while a session ending is.
+ *
+ * @evidence contracts/common.md#principled-implementation Reset immediately removes cached promises and the epoch, while fulfilled pending generations subsequently attempt their owned resource cleanup.
+ * @evidence contracts/common.md#clear-and-simple-design The exported lifecycle boundary delegates entry cleanup to one helper and separately removes the delivery-pass declaration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Reset is an explicit ownership boundary, not a per-module recompilation workaround or patched Promise behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why session reset differs from opening the next delivery pass.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Withdrawal snapshots N promises then schedules N reactions with O(N)
+ *   temporary references; epoch deletion is fixed work. Fulfilled reactions
+ *   additionally perform generation-owned watcher/probe cleanup, without
+ *   serially awaiting compiles or scanning project files here.
+ * @evidence contracts/performance.md#reuse-equivalent-work The explicit reset boundary preserves reuse across ordinary pass openings and shares the standard generation disposer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Entries and epoch are removed immediately, unlike volatile withdrawal.
+ *   Fulfilled generations transfer their handles/probes to disposal attempts;
+ *   pending compiles have no cancellation deadline and failed native cleanup
+ *   can leave underlying resources. No new lifecycle state is retained here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Reset delegates cleanup to each generation's actual native close and probe
+ *   owners, preserving their observing capability rather than assuming every
+ *   platform releases resources identically. Epoch deletion is separate scalar
+ *   lifecycle state and does not normalize filesystem keys.
+ */
+function resetTtscTransformCache(
+/** Cache ending its generation and declared delivery-pass ownership. */
+cache) {
+    withdrawTtscTransformGenerations(cache);
+    TRANSFORM_CACHE_EPOCHS.delete(cache);
+}
+
+export { resetTtscTransformCache };
+//# sourceMappingURL=resetTtscTransformCache.mjs.map

package/lib/core/transform/cache/resetTtscTransformCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resetTtscTransformCache.mjs","sources":["../../../../src/core/transform/cache/resetTtscTransformCache.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;SACa,uBAAuB;AACrC;AACA,KAAyB,EAAA;IAEzB,gCAAgC,CAAC,KAAK,CAAC;AACvC,IAAA,sBAAsB,CAAC,MAAM,CAAC,KAAK,CAAC;AACtC;;;;"}

package/lib/core/transform/cache/resultFilesystem.d.cts

@@ -0,0 +1,29 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+/**
+ * Return the filesystem view one compiler result is validated against.
+ *
+ * Capture and delivery owners register the operations view used for validation.
+ * They must keep that view coherent with the recorded observations; this lookup
+ * does not independently verify equivalence when a registration is replaced.
+ * Mixing an injected view with unrelated host reads would compare different
+ * filesystem states. Unregistered results fall back to the host filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Validation retrieves the result's registered operations instead of silently
+ *   substituting host reads. Capture and delivery registration own view coherence;
+ *   this selector alone does not establish that prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design A result-keyed WeakMap lookup selects the existing operations table, with one native default for unregistered results.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation does not patch host filesystem methods or assume that an injected filesystem is the native one.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why capture and validation must use the same filesystem view and states the unregistered-result default.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the result.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This selects an already registered operations table. Capture and delivery
+ *   owners govern registration and proof equivalence; no verdict is cached here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Selects the registered native filesystem capability boundary, including its
+ *   path grammar, case policy and observation methods. Only unregistered results
+ *   select the explicit host default; no OS name establishes view equivalence.
+ */
+export declare function resultFilesystem(result: ITtscCompilerTransformation): TtscTransformFilesystemOperations;

package/lib/core/transform/cache/resultFilesystem.d.mts

@@ -0,0 +1,29 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+/**
+ * Return the filesystem view one compiler result is validated against.
+ *
+ * Capture and delivery owners register the operations view used for validation.
+ * They must keep that view coherent with the recorded observations; this lookup
+ * does not independently verify equivalence when a registration is replaced.
+ * Mixing an injected view with unrelated host reads would compare different
+ * filesystem states. Unregistered results fall back to the host filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Validation retrieves the result's registered operations instead of silently
+ *   substituting host reads. Capture and delivery registration own view coherence;
+ *   this selector alone does not establish that prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design A result-keyed WeakMap lookup selects the existing operations table, with one native default for unregistered results.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation does not patch host filesystem methods or assume that an injected filesystem is the native one.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why capture and validation must use the same filesystem view and states the unregistered-result default.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the result.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This selects an already registered operations table. Capture and delivery
+ *   owners govern registration and proof equivalence; no verdict is cached here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Selects the registered native filesystem capability boundary, including its
+ *   path grammar, case policy and observation methods. Only unregistered results
+ *   select the explicit host default; no OS name establishes view equivalence.
+ */
+export declare function resultFilesystem(result: ITtscCompilerTransformation): TtscTransformFilesystemOperations;

package/lib/core/transform/cache/resultFilesystem.d.ts

@@ -0,0 +1,29 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+/**
+ * Return the filesystem view one compiler result is validated against.
+ *
+ * Capture and delivery owners register the operations view used for validation.
+ * They must keep that view coherent with the recorded observations; this lookup
+ * does not independently verify equivalence when a registration is replaced.
+ * Mixing an injected view with unrelated host reads would compare different
+ * filesystem states. Unregistered results fall back to the host filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Validation retrieves the result's registered operations instead of silently
+ *   substituting host reads. Capture and delivery registration own view coherence;
+ *   this selector alone does not establish that prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design A result-keyed WeakMap lookup selects the existing operations table, with one native default for unregistered results.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation does not patch host filesystem methods or assume that an injected filesystem is the native one.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why capture and validation must use the same filesystem view and states the unregistered-result default.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the result.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This selects an already registered operations table. Capture and delivery
+ *   owners govern registration and proof equivalence; no verdict is cached here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Selects the registered native filesystem capability boundary, including its
+ *   path grammar, case policy and observation methods. Only unregistered results
+ *   select the explicit host default; no OS name establishes view equivalence.
+ */
+export declare function resultFilesystem(result: ITtscCompilerTransformation): TtscTransformFilesystemOperations;

package/lib/core/transform/cache/resultFilesystem.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var TRANSFORM_RESULT_FILESYSTEM = require('./TRANSFORM_RESULT_FILESYSTEM.js');
+
+/**
+ * Return the filesystem view one compiler result is validated against.
+ *
+ * Capture and delivery owners register the operations view used for validation.
+ * They must keep that view coherent with the recorded observations; this lookup
+ * does not independently verify equivalence when a registration is replaced.
+ * Mixing an injected view with unrelated host reads would compare different
+ * filesystem states. Unregistered results fall back to the host filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Validation retrieves the result's registered operations instead of silently
+ *   substituting host reads. Capture and delivery registration own view coherence;
+ *   this selector alone does not establish that prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design A result-keyed WeakMap lookup selects the existing operations table, with one native default for unregistered results.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation does not patch host filesystem methods or assume that an injected filesystem is the native one.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why capture and validation must use the same filesystem view and states the unregistered-result default.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the result.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This selects an already registered operations table. Capture and delivery
+ *   owners govern registration and proof equivalence; no verdict is cached here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Selects the registered native filesystem capability boundary, including its
+ *   path grammar, case policy and observation methods. Only unregistered results
+ *   select the explicit host default; no OS name establishes view equivalence.
+ */
+function resultFilesystem(result) {
+    return (TRANSFORM_RESULT_FILESYSTEM.TRANSFORM_RESULT_FILESYSTEM.get(result) ?? DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS);
+}
+
+exports.resultFilesystem = resultFilesystem;
+//# sourceMappingURL=resultFilesystem.js.map

package/lib/core/transform/cache/resultFilesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultFilesystem.js","sources":["../../../../src/core/transform/cache/resultFilesystem.ts"],"sourcesContent":[null],"names":["TRANSFORM_RESULT_FILESYSTEM","DEFAULT_FILESYSTEM_OPERATIONS"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,gBAAgB,CAC9B,MAAmC,EAAA;IAEnC,QACEA,uDAA2B,CAAC,GAAG,CAAC,MAAM,CAAC,IAAIC,2DAA6B;AAE5E;;;;"}

package/lib/core/transform/cache/resultFilesystem.mjs

@@ -0,0 +1,35 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { TRANSFORM_RESULT_FILESYSTEM } from './TRANSFORM_RESULT_FILESYSTEM.mjs';
+
+/**
+ * Return the filesystem view one compiler result is validated against.
+ *
+ * Capture and delivery owners register the operations view used for validation.
+ * They must keep that view coherent with the recorded observations; this lookup
+ * does not independently verify equivalence when a registration is replaced.
+ * Mixing an injected view with unrelated host reads would compare different
+ * filesystem states. Unregistered results fall back to the host filesystem.
+ *
+ * @evidence contracts/common.md#principled-implementation
+ *   Validation retrieves the result's registered operations instead of silently
+ *   substituting host reads. Capture and delivery registration own view coherence;
+ *   this selector alone does not establish that prerequisite.
+ * @evidence contracts/common.md#clear-and-simple-design A result-keyed WeakMap lookup selects the existing operations table, with one native default for unregistered results.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation does not patch host filesystem methods or assume that an injected filesystem is the native one.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why capture and validation must use the same filesystem view and states the unregistered-result default.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retains nothing; the table is weakly keyed by the result.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One WeakMap lookup.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   This selects an already registered operations table. Capture and delivery
+ *   owners govern registration and proof equivalence; no verdict is cached here.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Selects the registered native filesystem capability boundary, including its
+ *   path grammar, case policy and observation methods. Only unregistered results
+ *   select the explicit host default; no OS name establishes view equivalence.
+ */
+function resultFilesystem(result) {
+    return (TRANSFORM_RESULT_FILESYSTEM.get(result) ?? DEFAULT_FILESYSTEM_OPERATIONS);
+}
+
+export { resultFilesystem };
+//# sourceMappingURL=resultFilesystem.mjs.map

package/lib/core/transform/cache/resultFilesystem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultFilesystem.mjs","sources":["../../../../src/core/transform/cache/resultFilesystem.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,gBAAgB,CAC9B,MAAmC,EAAA;IAEnC,QACE,2BAA2B,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,6BAA6B;AAE5E;;;;"}

package/lib/core/transform/cache/retainPassVerdict.d.cts

@@ -0,0 +1,26 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTerminalGenerationError } from "../errors/TtscTerminalGenerationError.cjs";
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.cjs";
+import type { TtscTransformCache } from "./TtscTransformCache.cjs";
+/**
+ * Retain the verdict of a compile this pass already attempted, or return
+ * `undefined` when nothing may be retained.
+ *
+ * Only inside a delivery pass. A pass is the window in which every delivery is
+ * settled against the state the pass started from, so an attempt it already
+ * made is part of that state and the remaining modules replay it rather than
+ * each repeating a whole-project transform to reach the same answer. Outside a
+ * pass there is no such window, and a long-lived worker must keep retrying on
+ * its very next delivery so a transient host failure never becomes permanent.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires a failed envelope, a declared epoch, and the same current promise; success with one missing output cannot become a generation-wide verdict.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap stores the existing or newly wrapped verdict for that promise, keeping pass identity in the error instead of adding another cache-entry format.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The original failure remains observable and its retention cannot escape the declared pass or conceal a successful envelope's per-module absence.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the pass's reuse rationale and why persistent workers outside a pass must retry transient failures.
+ * @evidence contracts/performance.md#efficient-algorithms Current-promise and epoch guards precede one weak lookup; only a new verdict formats a non-Error cause, with text-length scanning and any caller-defined String conversion. Remaining deliveries reuse the verdict without repeating that formatting or whole-project work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Remaining modules reuse the same observed failed attempt only in its pass; a successful envelope's missing output is never promoted to a reusable generation failure.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One verdict is weakly keyed by its generation promise, and the stored epoch limits replay authority to the owning pass.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+export declare function retainPassVerdict(cache: TtscTransformCache | undefined, key: string, generation: Promise<TtscCachedProjectTransform>, epoch: number | undefined, result: ITtscCompilerTransformation, error: unknown): TtscTerminalGenerationError | undefined;

package/lib/core/transform/cache/retainPassVerdict.d.mts

@@ -0,0 +1,26 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTerminalGenerationError } from "../errors/TtscTerminalGenerationError.mjs";
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform.mjs";
+import type { TtscTransformCache } from "./TtscTransformCache.mjs";
+/**
+ * Retain the verdict of a compile this pass already attempted, or return
+ * `undefined` when nothing may be retained.
+ *
+ * Only inside a delivery pass. A pass is the window in which every delivery is
+ * settled against the state the pass started from, so an attempt it already
+ * made is part of that state and the remaining modules replay it rather than
+ * each repeating a whole-project transform to reach the same answer. Outside a
+ * pass there is no such window, and a long-lived worker must keep retrying on
+ * its very next delivery so a transient host failure never becomes permanent.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires a failed envelope, a declared epoch, and the same current promise; success with one missing output cannot become a generation-wide verdict.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap stores the existing or newly wrapped verdict for that promise, keeping pass identity in the error instead of adding another cache-entry format.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The original failure remains observable and its retention cannot escape the declared pass or conceal a successful envelope's per-module absence.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the pass's reuse rationale and why persistent workers outside a pass must retry transient failures.
+ * @evidence contracts/performance.md#efficient-algorithms Current-promise and epoch guards precede one weak lookup; only a new verdict formats a non-Error cause, with text-length scanning and any caller-defined String conversion. Remaining deliveries reuse the verdict without repeating that formatting or whole-project work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Remaining modules reuse the same observed failed attempt only in its pass; a successful envelope's missing output is never promoted to a reusable generation failure.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One verdict is weakly keyed by its generation promise, and the stored epoch limits replay authority to the owning pass.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+export declare function retainPassVerdict(cache: TtscTransformCache | undefined, key: string, generation: Promise<TtscCachedProjectTransform>, epoch: number | undefined, result: ITtscCompilerTransformation, error: unknown): TtscTerminalGenerationError | undefined;

package/lib/core/transform/cache/retainPassVerdict.d.ts

@@ -0,0 +1,26 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTerminalGenerationError } from "../errors/TtscTerminalGenerationError";
+import type { TtscCachedProjectTransform } from "./TtscCachedProjectTransform";
+import type { TtscTransformCache } from "./TtscTransformCache";
+/**
+ * Retain the verdict of a compile this pass already attempted, or return
+ * `undefined` when nothing may be retained.
+ *
+ * Only inside a delivery pass. A pass is the window in which every delivery is
+ * settled against the state the pass started from, so an attempt it already
+ * made is part of that state and the remaining modules replay it rather than
+ * each repeating a whole-project transform to reach the same answer. Outside a
+ * pass there is no such window, and a long-lived worker must keep retrying on
+ * its very next delivery so a transient host failure never becomes permanent.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires a failed envelope, a declared epoch, and the same current promise; success with one missing output cannot become a generation-wide verdict.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap stores the existing or newly wrapped verdict for that promise, keeping pass identity in the error instead of adding another cache-entry format.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The original failure remains observable and its retention cannot escape the declared pass or conceal a successful envelope's per-module absence.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the pass's reuse rationale and why persistent workers outside a pass must retry transient failures.
+ * @evidence contracts/performance.md#efficient-algorithms Current-promise and epoch guards precede one weak lookup; only a new verdict formats a non-Error cause, with text-length scanning and any caller-defined String conversion. Remaining deliveries reuse the verdict without repeating that formatting or whole-project work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Remaining modules reuse the same observed failed attempt only in its pass; a successful envelope's missing output is never promoted to a reusable generation failure.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One verdict is weakly keyed by its generation promise, and the stored epoch limits replay authority to the owning pass.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+export declare function retainPassVerdict(cache: TtscTransformCache | undefined, key: string, generation: Promise<TtscCachedProjectTransform>, epoch: number | undefined, result: ITtscCompilerTransformation, error: unknown): TtscTerminalGenerationError | undefined;

package/lib/core/transform/cache/retainPassVerdict.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var TtscPassVerdictError = require('../errors/TtscPassVerdictError.js');
+var TERMINAL_TRANSFORM_GENERATIONS = require('./TERMINAL_TRANSFORM_GENERATIONS.js');
+
+/**
+ * Retain the verdict of a compile this pass already attempted, or return
+ * `undefined` when nothing may be retained.
+ *
+ * Only inside a delivery pass. A pass is the window in which every delivery is
+ * settled against the state the pass started from, so an attempt it already
+ * made is part of that state and the remaining modules replay it rather than
+ * each repeating a whole-project transform to reach the same answer. Outside a
+ * pass there is no such window, and a long-lived worker must keep retrying on
+ * its very next delivery so a transient host failure never becomes permanent.
+ *
+ * @evidence contracts/common.md#principled-implementation Retention requires a failed envelope, a declared epoch, and the same current promise; success with one missing output cannot become a generation-wide verdict.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap stores the existing or newly wrapped verdict for that promise, keeping pass identity in the error instead of adding another cache-entry format.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The original failure remains observable and its retention cannot escape the declared pass or conceal a successful envelope's per-module absence.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the pass's reuse rationale and why persistent workers outside a pass must retry transient failures.
+ * @evidence contracts/performance.md#efficient-algorithms Current-promise and epoch guards precede one weak lookup; only a new verdict formats a non-Error cause, with text-length scanning and any caller-defined String conversion. Remaining deliveries reuse the verdict without repeating that formatting or whole-project work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Remaining modules reuse the same observed failed attempt only in its pass; a successful envelope's missing output is never promoted to a reusable generation failure.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One verdict is weakly keyed by its generation promise, and the stored epoch limits replay authority to the owning pass.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ */
+function retainPassVerdict(cache, key, generation, epoch, result, error) {
+    // Only an envelope that failed outright is a statement about the generation.
+    // `selectTransformedSource` also throws for a file the compile simply has no
+    // output for, which is an ordinary condition for a module the bundle reaches
+    // but the tsconfig program does not contain, and which says nothing about the
+    // other modules. Retaining that would fail the whole pass, naming a file none
+    // of them asked about.
+    if (result.type === "success" ||
+        epoch === undefined ||
+        cache?.get(key) !== generation) {
+        return undefined;
+    }
+    const existing = TERMINAL_TRANSFORM_GENERATIONS.TERMINAL_TRANSFORM_GENERATIONS.get(generation);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const verdict = new TtscPassVerdictError.TtscPassVerdictError(error, epoch);
+    TERMINAL_TRANSFORM_GENERATIONS.TERMINAL_TRANSFORM_GENERATIONS.set(generation, verdict);
+    return verdict;
+}
+
+exports.retainPassVerdict = retainPassVerdict;
+//# sourceMappingURL=retainPassVerdict.js.map

package/lib/core/transform/cache/retainPassVerdict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainPassVerdict.js","sources":["../../../../src/core/transform/cache/retainPassVerdict.ts"],"sourcesContent":[null],"names":["TERMINAL_TRANSFORM_GENERATIONS","TtscPassVerdictError"],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,iBAAiB,CAC/B,KAAqC,EACrC,GAAW,EACX,UAA+C,EAC/C,KAAyB,EACzB,MAAmC,EACnC,KAAc,EAAA;;;;;;;AAQd,IAAA,IACE,MAAM,CAAC,IAAI,KAAK,SAAS;AACzB,QAAA,KAAK,KAAK,SAAS;QACnB,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,KAAK,UAAU,EAC9B;AACA,QAAA,OAAO,SAAS;IAClB;IACA,MAAM,QAAQ,GAAGA,6DAA8B,CAAC,GAAG,CAAC,UAAU,CAAC;AAC/D,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;AAC1B,QAAA,OAAO,QAAQ;IACjB;IACA,MAAM,OAAO,GAAG,IAAIC,yCAAoB,CAAC,KAAK,EAAE,KAAK,CAAC;AACtD,IAAAD,6DAA8B,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC;AACvD,IAAA,OAAO,OAAO;AAChB;;;;"}