@ttsc/unplugin 0.30.4 → 0.31.1

package/lib/core/transform/validation/compilerGraphInputProofFailures.mjs

@@ -0,0 +1,161 @@
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { envelopeGraphIndexes } from '../envelope/envelopeGraphIndexes.mjs';
+import { legacyProjectionOfGraphInputObservation } from '../envelope/legacyProjectionOfGraphInputObservation.mjs';
+import { createGenerationProofFailures } from '../generation/createGenerationProofFailures.mjs';
+import { recordGenerationProofFailure } from '../generation/recordGenerationProofFailure.mjs';
+import { graphInputObservationFailures } from '../inputs/graphInputObservationFailures.mjs';
+import { graphInputStateHash } from '../inputs/graphInputStateHash.mjs';
+import { hostInputRealpath } from '../inputs/hostInputRealpath.mjs';
+import { sameHostInputRealpath } from '../inputs/sameHostInputRealpath.mjs';
+import { isTransformScratchInput } from '../tsconfig/isTransformScratchInput.mjs';
+
+/**
+ * Collect bounded witnesses of graph input mismatch or unavailable authority.
+ *
+ * Persistent rich predicates are replayed once. Their legacy projection, when
+ * also supplied, checks producer consistency. Adapter-owned scratch inputs are
+ * excluded from every proof population: a published envelope retains its
+ * publisher's scratch address after that temporary tree has been disposed.
+ * Legacy envelopes without sidecar populations keep the existing snapshot
+ * policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Persistent predicate replay and legacy projection consistency distinguish a changed environment from conflicting or missing producer authority. Every proof population excludes the actual adapter-owned scratch tree retained by the generation, so disposing the publisher's wrapper does not refute its adopted output.
+ * @evidence contracts/common.md#clear-and-simple-design One validator accumulates classified failures while envelope indexing and native codecs own normalization and observation semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting representations are rejected rather than choosing whichever proof happens to pass; legacy absence is handled only by the established snapshot boundary.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains predicate replay, projection consistency, scratch exclusion and the limited legacy boundary before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Recorded lexical spellings are replayed through the owning filesystem and identity context rather than OS-name-derived case assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The classified failure DTO transfers to its caller; all temporary sets are local and no handle or historical population is retained.
+ * @evidence contracts/performance.md#efficient-algorithms Graph indexing is generation-owned; this pass visits R predicates/conflicts and M member spellings, with native scratch containment checks per reached spelling, temporary sets and bounded failure records. Native path text, identity/metadata/byte decoding/hashing/listing and observation failure arrays remain delegated costs; JSON witness text is not fixed-size work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Rich predicates are replayed once per indexed spelling and their legacy branch checks representation consistency without another content read. This shares that requested native verdict within this pass; later generation admission decides whether it remains usable, not this local set alone.
+ */
+function compilerGraphInputProofFailures(cached) {
+    const failures = createGenerationProofFailures();
+    if (cached.result.type === "exception" ||
+        cached.result.graph === undefined ||
+        (cached.result.graph.inputHashes === undefined &&
+            cached.result.graph.inputObservations === undefined &&
+            cached.result.graph.inputRealpaths === undefined &&
+            cached.result.graph.inputProofFailures === undefined)) {
+        // Legacy sidecars remain compatible for ordinary in-project graphs. Their
+        // out-of-walk members are still rejected by captureExternalInputSnapshot,
+        // where a post-compile snapshot cannot prove the compiler's generation.
+        return failures;
+    }
+    const state = envelopeDerivation(cached);
+    const filesystem = resultFilesystem(cached.result);
+    const graph = envelopeGraphIndexes(state, cached);
+    const predicateSpellings = new Set();
+    const predicateConflictSpellings = new Set();
+    for (const [spelling, observation] of graph.inputObservations) {
+        if (isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            continue;
+        }
+        predicateSpellings.add(spelling);
+        for (const kind of graphInputObservationFailures(spelling, observation, filesystem, state.identityContext)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind,
+                path: spelling,
+            });
+        }
+    }
+    for (const spelling of graph.inputObservationConflicts) {
+        if (isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            continue;
+        }
+        predicateSpellings.add(spelling);
+        predicateConflictSpellings.add(spelling);
+        recordGenerationProofFailure(failures, {
+            domain: "graph",
+            kind: "proof-conflict",
+            detail: graph.inputProofFailures.get(spelling),
+            path: spelling,
+        });
+    }
+    for (const spelling of graph.memberSpellings) {
+        const proof = graph.inputProofs.get(spelling);
+        if (isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            continue;
+        }
+        if (predicateConflictSpellings.has(spelling)) {
+            continue;
+        }
+        if (graph.inputProofConflicts.has(spelling)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-conflict",
+                detail: graph.inputProofFailures.get(spelling),
+                path: spelling,
+            });
+            continue;
+        }
+        if (graph.inputProofFailures.has(spelling)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-missing",
+                detail: graph.inputProofFailures.get(spelling),
+                path: spelling,
+            });
+            continue;
+        }
+        const observation = graph.inputObservations.get(spelling);
+        if (observation !== undefined && proof !== undefined) {
+            const projection = legacyProjectionOfGraphInputObservation(observation);
+            if (projection.failure !== undefined ||
+                projection.hash !== proof.hash ||
+                !sameHostInputRealpath(projection.realpath, proof.realpath, state.identityContext)) {
+                recordGenerationProofFailure(failures, {
+                    domain: "graph",
+                    kind: "proof-conflict",
+                    detail: projection.failure,
+                    path: spelling,
+                });
+            }
+            // The rich predicates were already replayed above. Their legacy
+            // projection is an internal producer-consistency check, never a reason
+            // to read the same filesystem input again. A projection that cannot
+            // represent the observation is itself inconsistent with a supplied
+            // legacy proof, rather than permission to trust either representation.
+            continue;
+        }
+        if (graph.speculative.has(spelling) &&
+            predicateSpellings.has(spelling) &&
+            !graph.inputProofFailures.has(spelling)) {
+            continue;
+        }
+        // A legacy sidecar can report a resolver candidate without a compiler
+        // predicate. Validate it against the generation snapshot instead.
+        if (proof === undefined && graph.speculative.has(spelling)) {
+            continue;
+        }
+        if (proof === undefined) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-missing",
+                detail: graph.inputProofFailures.get(spelling),
+                path: spelling,
+            });
+            continue;
+        }
+        const currentHash = graphInputStateHash(proof.path, filesystem);
+        if (currentHash !== proof.hash) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "content-changed",
+                path: proof.path,
+            });
+        }
+        if (!sameHostInputRealpath(proof.realpath, hostInputRealpath(proof.path, filesystem), state.identityContext)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "realpath-changed",
+                path: proof.path,
+            });
+        }
+    }
+    return failures;
+}
+
+export { compilerGraphInputProofFailures };
+//# sourceMappingURL=compilerGraphInputProofFailures.mjs.map

package/lib/core/transform/validation/compilerGraphInputProofFailures.mjs.map

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

package/lib/core/transform/validation/inputSignatureSlot.d.cts

@@ -0,0 +1,34 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation.cjs";
+/**
+ * Locate the signature manifest that owns one recorded input, mirroring
+ * `matchesRecordedInput`'s own preference for the out-of-walk spelling's
+ * snapshot over the walked project's.
+ *
+ * The manifest is returned whether or not it currently holds a signature for
+ * the input, so a content comparison that succeeds can record one. Without
+ * that, an input whose capture-time metadata was too recent to prove anything
+ * would keep its content read for the whole life of the generation, since
+ * nothing else ever revisits it. Returns undefined for predicate-bearing inputs
+ * or inputs without a recorded scalar hash: neither has a scalar signature slot
+ * to update.
+ *
+ * @evidence contracts/common.md#principled-implementation Predicate observations have no scalar slot; external spelling snapshots take precedence over project hashes and separate physical content keys from lexical metadata keys.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup exposes the actual owning signature manifest so validators update its proof without duplicating precedence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An input without a recorded hash cannot acquire a metadata substitute through an invented slot.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, lazy signature admission and the exact undefined condition before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution supplies metadata spelling while derivationIdentity and toProjectKey apply the generation's actual filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms Native identity and project-key selection use the supplied transaction rather than scanning input populations. Path resolution, key hashing and formatting scale with path text, and a transaction miss pays native identity and case observations; fixed field probes do not make that work constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Hands back the existing signature record on the cached transform instead
+ *   of rebuilding it.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation lazily attaches a signature record to the borrowed cached transform and returns its slot. Validators populate it and the generation owner controls its lifetime; this lookup owns no separate history, handle or release boundary.
+ */
+export declare function inputSignatureSlot(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string): {
+    /** Metadata key in the actual owning signature manifest. */
+    key: string;
+    /** Authoritative scalar content or missing-state value. */
+    recorded: string;
+    /** Generation-owned signature manifest updated after qualified reads. */
+    signatures: Record<string, string>;
+} | undefined;

package/lib/core/transform/validation/inputSignatureSlot.d.mts

@@ -0,0 +1,34 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation.mjs";
+/**
+ * Locate the signature manifest that owns one recorded input, mirroring
+ * `matchesRecordedInput`'s own preference for the out-of-walk spelling's
+ * snapshot over the walked project's.
+ *
+ * The manifest is returned whether or not it currently holds a signature for
+ * the input, so a content comparison that succeeds can record one. Without
+ * that, an input whose capture-time metadata was too recent to prove anything
+ * would keep its content read for the whole life of the generation, since
+ * nothing else ever revisits it. Returns undefined for predicate-bearing inputs
+ * or inputs without a recorded scalar hash: neither has a scalar signature slot
+ * to update.
+ *
+ * @evidence contracts/common.md#principled-implementation Predicate observations have no scalar slot; external spelling snapshots take precedence over project hashes and separate physical content keys from lexical metadata keys.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup exposes the actual owning signature manifest so validators update its proof without duplicating precedence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An input without a recorded hash cannot acquire a metadata substitute through an invented slot.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, lazy signature admission and the exact undefined condition before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution supplies metadata spelling while derivationIdentity and toProjectKey apply the generation's actual filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms Native identity and project-key selection use the supplied transaction rather than scanning input populations. Path resolution, key hashing and formatting scale with path text, and a transaction miss pays native identity and case observations; fixed field probes do not make that work constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Hands back the existing signature record on the cached transform instead
+ *   of rebuilding it.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation lazily attaches a signature record to the borrowed cached transform and returns its slot. Validators populate it and the generation owner controls its lifetime; this lookup owns no separate history, handle or release boundary.
+ */
+export declare function inputSignatureSlot(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string): {
+    /** Metadata key in the actual owning signature manifest. */
+    key: string;
+    /** Authoritative scalar content or missing-state value. */
+    recorded: string;
+    /** Generation-owned signature manifest updated after qualified reads. */
+    signatures: Record<string, string>;
+} | undefined;

package/lib/core/transform/validation/inputSignatureSlot.d.ts

@@ -0,0 +1,34 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation";
+/**
+ * Locate the signature manifest that owns one recorded input, mirroring
+ * `matchesRecordedInput`'s own preference for the out-of-walk spelling's
+ * snapshot over the walked project's.
+ *
+ * The manifest is returned whether or not it currently holds a signature for
+ * the input, so a content comparison that succeeds can record one. Without
+ * that, an input whose capture-time metadata was too recent to prove anything
+ * would keep its content read for the whole life of the generation, since
+ * nothing else ever revisits it. Returns undefined for predicate-bearing inputs
+ * or inputs without a recorded scalar hash: neither has a scalar signature slot
+ * to update.
+ *
+ * @evidence contracts/common.md#principled-implementation Predicate observations have no scalar slot; external spelling snapshots take precedence over project hashes and separate physical content keys from lexical metadata keys.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup exposes the actual owning signature manifest so validators update its proof without duplicating precedence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An input without a recorded hash cannot acquire a metadata substitute through an invented slot.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, lazy signature admission and the exact undefined condition before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution supplies metadata spelling while derivationIdentity and toProjectKey apply the generation's actual filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms Native identity and project-key selection use the supplied transaction rather than scanning input populations. Path resolution, key hashing and formatting scale with path text, and a transaction miss pays native identity and case observations; fixed field probes do not make that work constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Hands back the existing signature record on the cached transform instead
+ *   of rebuilding it.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation lazily attaches a signature record to the borrowed cached transform and returns its slot. Validators populate it and the generation owner controls its lifetime; this lookup owns no separate history, handle or release boundary.
+ */
+export declare function inputSignatureSlot(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string): {
+    /** Metadata key in the actual owning signature manifest. */
+    key: string;
+    /** Authoritative scalar content or missing-state value. */
+    recorded: string;
+    /** Generation-owned signature manifest updated after qualified reads. */
+    signatures: Record<string, string>;
+} | undefined;

package/lib/core/transform/validation/inputSignatureSlot.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var path = require('node:path');
+var derivationIdentity = require('../envelope/derivationIdentity.js');
+var toProjectKey = require('../project/toProjectKey.js');
+
+/**
+ * Locate the signature manifest that owns one recorded input, mirroring
+ * `matchesRecordedInput`'s own preference for the out-of-walk spelling's
+ * snapshot over the walked project's.
+ *
+ * The manifest is returned whether or not it currently holds a signature for
+ * the input, so a content comparison that succeeds can record one. Without
+ * that, an input whose capture-time metadata was too recent to prove anything
+ * would keep its content read for the whole life of the generation, since
+ * nothing else ever revisits it. Returns undefined for predicate-bearing inputs
+ * or inputs without a recorded scalar hash: neither has a scalar signature slot
+ * to update.
+ *
+ * @evidence contracts/common.md#principled-implementation Predicate observations have no scalar slot; external spelling snapshots take precedence over project hashes and separate physical content keys from lexical metadata keys.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup exposes the actual owning signature manifest so validators update its proof without duplicating precedence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An input without a recorded hash cannot acquire a metadata substitute through an invented slot.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, lazy signature admission and the exact undefined condition before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution supplies metadata spelling while derivationIdentity and toProjectKey apply the generation's actual filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms Native identity and project-key selection use the supplied transaction rather than scanning input populations. Path resolution, key hashing and formatting scale with path text, and a transaction miss pays native identity and case observations; fixed field probes do not make that work constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Hands back the existing signature record on the cached transform instead
+ *   of rebuilding it.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation lazily attaches a signature record to the borrowed cached transform and returns its slot. Validators populate it and the generation owner controls its lifetime; this lookup owns no separate history, handle or release boundary.
+ */
+function inputSignatureSlot(cached, state, input) {
+    const identity = derivationIdentity.derivationIdentity(state, input);
+    if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+        return undefined;
+    }
+    const external = cached.externalInputHashes ?? {};
+    if (Object.prototype.hasOwnProperty.call(external, identity)) {
+        // The recorded hash is identity-keyed because aliases of one physical file
+        // share its content; the signature is spelling-keyed because they do not
+        // share its metadata.
+        return {
+            key: path.resolve(input),
+            recorded: external[identity],
+            signatures: (cached.externalInputSignatures ??= {}),
+        };
+    }
+    const projectKey = toProjectKey.toProjectKey(cached.projectRoot, input, state.identityContext);
+    return Object.prototype.hasOwnProperty.call(cached.inputHashes, projectKey)
+        ? {
+            key: projectKey,
+            recorded: cached.inputHashes[projectKey],
+            signatures: (cached.inputSignatures ??= {}),
+        }
+        : undefined;
+}
+
+exports.inputSignatureSlot = inputSignatureSlot;
+//# sourceMappingURL=inputSignatureSlot.js.map

package/lib/core/transform/validation/inputSignatureSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSignatureSlot.js","sources":["../../../../src/core/transform/validation/inputSignatureSlot.ts"],"sourcesContent":[null],"names":["derivationIdentity","toProjectKey"],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;SACa,kBAAkB,CAChC,MAAkC,EAClC,KAA6B,EAC7B,KAAa,EAAA;IAab,MAAM,QAAQ,GAAGA,qCAAkB,CAAC,KAAK,EAAE,KAAK,CAAC;AACjD,IAAA,IAAI,MAAM,CAAC,yBAAyB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,SAAS,EAAE;AACzE,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,mBAAmB,IAAI,EAAE;AACjD,IAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;;;;QAI5D,OAAO;AACL,YAAA,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;AACxB,YAAA,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAE;AAC7B,YAAA,UAAU,GAAG,MAAM,CAAC,uBAAuB,KAAK,EAAE,CAAC;SACpD;IACH;AACA,IAAA,MAAM,UAAU,GAAGC,yBAAY,CAC7B,MAAM,CAAC,WAAW,EAClB,KAAK,EACL,KAAK,CAAC,eAAe,CACtB;AACD,IAAA,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU;AACxE,UAAE;AACE,YAAA,GAAG,EAAE,UAAU;AACf,YAAA,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAE;AACzC,YAAA,UAAU,GAAG,MAAM,CAAC,eAAe,KAAK,EAAE,CAAC;AAC5C;UACD,SAAS;AACf;;;;"}

package/lib/core/transform/validation/inputSignatureSlot.mjs

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { derivationIdentity } from '../envelope/derivationIdentity.mjs';
+import { toProjectKey } from '../project/toProjectKey.mjs';
+
+/**
+ * Locate the signature manifest that owns one recorded input, mirroring
+ * `matchesRecordedInput`'s own preference for the out-of-walk spelling's
+ * snapshot over the walked project's.
+ *
+ * The manifest is returned whether or not it currently holds a signature for
+ * the input, so a content comparison that succeeds can record one. Without
+ * that, an input whose capture-time metadata was too recent to prove anything
+ * would keep its content read for the whole life of the generation, since
+ * nothing else ever revisits it. Returns undefined for predicate-bearing inputs
+ * or inputs without a recorded scalar hash: neither has a scalar signature slot
+ * to update.
+ *
+ * @evidence contracts/common.md#principled-implementation Predicate observations have no scalar slot; external spelling snapshots take precedence over project hashes and separate physical content keys from lexical metadata keys.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup exposes the actual owning signature manifest so validators update its proof without duplicating precedence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An input without a recorded hash cannot acquire a metadata substitute through an invented slot.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain precedence, lazy signature admission and the exact undefined condition before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lexical resolution supplies metadata spelling while derivationIdentity and toProjectKey apply the generation's actual filesystem identity context.
+ * @evidence contracts/performance.md#efficient-algorithms Native identity and project-key selection use the supplied transaction rather than scanning input populations. Path resolution, key hashing and formatting scale with path text, and a transaction miss pays native identity and case observations; fixed field probes do not make that work constant.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Hands back the existing signature record on the cached transform instead
+ *   of rebuilding it.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation lazily attaches a signature record to the borrowed cached transform and returns its slot. Validators populate it and the generation owner controls its lifetime; this lookup owns no separate history, handle or release boundary.
+ */
+function inputSignatureSlot(cached, state, input) {
+    const identity = derivationIdentity(state, input);
+    if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+        return undefined;
+    }
+    const external = cached.externalInputHashes ?? {};
+    if (Object.prototype.hasOwnProperty.call(external, identity)) {
+        // The recorded hash is identity-keyed because aliases of one physical file
+        // share its content; the signature is spelling-keyed because they do not
+        // share its metadata.
+        return {
+            key: path.resolve(input),
+            recorded: external[identity],
+            signatures: (cached.externalInputSignatures ??= {}),
+        };
+    }
+    const projectKey = toProjectKey(cached.projectRoot, input, state.identityContext);
+    return Object.prototype.hasOwnProperty.call(cached.inputHashes, projectKey)
+        ? {
+            key: projectKey,
+            recorded: cached.inputHashes[projectKey],
+            signatures: (cached.inputSignatures ??= {}),
+        }
+        : undefined;
+}
+
+export { inputSignatureSlot };
+//# sourceMappingURL=inputSignatureSlot.mjs.map

package/lib/core/transform/validation/inputSignatureSlot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSignatureSlot.mjs","sources":["../../../../src/core/transform/validation/inputSignatureSlot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;SACa,kBAAkB,CAChC,MAAkC,EAClC,KAA6B,EAC7B,KAAa,EAAA;IAab,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC;AACjD,IAAA,IAAI,MAAM,CAAC,yBAAyB,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,SAAS,EAAE;AACzE,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,mBAAmB,IAAI,EAAE;AACjD,IAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;;;;QAI5D,OAAO;AACL,YAAA,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;AACxB,YAAA,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAE;AAC7B,YAAA,UAAU,GAAG,MAAM,CAAC,uBAAuB,KAAK,EAAE,CAAC;SACpD;IACH;AACA,IAAA,MAAM,UAAU,GAAG,YAAY,CAC7B,MAAM,CAAC,WAAW,EAClB,KAAK,EACL,KAAK,CAAC,eAAe,CACtB;AACD,IAAA,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU;AACxE,UAAE;AACE,YAAA,GAAG,EAAE,UAAU;AACf,YAAA,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAE;AACzC,YAAA,UAAU,GAAG,MAAM,CAAC,eAAe,KAAK,EAAE,CAAC;AAC5C;UACD,SAAS;AACf;;;;"}

package/lib/core/transform/validation/markCachedSourceServed.d.cts

@@ -0,0 +1,31 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/**
+ * Record a module after admitted output selection and watch notification.
+ *
+ * TransformTtsc also marks an admitted missing-output return, then hands the
+ * source back unchanged. For actual output it marks before constructing the
+ * final host value; this is a generation validation checkpoint, not a guarantee
+ * that downstream result construction or the host's delivery completed.
+ *
+ * @evidence contracts/common.md#principled-implementation The generation's path identity key records the caller's admitted selection checkpoint across equivalent spellings, enabling first-versus-later validation without claiming completed host delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns delivery-set insertion while transformTtsc owns successful selection timing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual transformTtsc call sites follow output selection or the typed missing-output continuation and completed watch notification; a mere cache hit or generic selection failure does not call this marker.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the admitted checkpoint, missing-output continuation and later host-result construction from completed delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation Identity follows the envelope's filesystem context and actual case policy rather than lowercasing paths by OS name.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Set insertion hashes the identity text; envelope state lookup shares an
+ *   existing transaction or initializes native root identity on first use.
+ *   Uncached path resolution may observe aliases, ancestors and directory case
+ *   policy, so delegation is not constant work independent of spelling length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The servedFiles set records each served file once.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct served identities and their
+ *   text. A successfully proven new epoch clears it; generation retirement
+ *   leaves it collectible with the generation, without a separate native handle.
+ */
+export declare function markCachedSourceServed(
+/** Generation owning the served set and native identity transaction. */
+cached: TtscCachedProjectTransform, 
+/** Admitted native source spelling converted to the generation identity. */
+file: string): void;

package/lib/core/transform/validation/markCachedSourceServed.d.mts

@@ -0,0 +1,31 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/**
+ * Record a module after admitted output selection and watch notification.
+ *
+ * TransformTtsc also marks an admitted missing-output return, then hands the
+ * source back unchanged. For actual output it marks before constructing the
+ * final host value; this is a generation validation checkpoint, not a guarantee
+ * that downstream result construction or the host's delivery completed.
+ *
+ * @evidence contracts/common.md#principled-implementation The generation's path identity key records the caller's admitted selection checkpoint across equivalent spellings, enabling first-versus-later validation without claiming completed host delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns delivery-set insertion while transformTtsc owns successful selection timing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual transformTtsc call sites follow output selection or the typed missing-output continuation and completed watch notification; a mere cache hit or generic selection failure does not call this marker.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the admitted checkpoint, missing-output continuation and later host-result construction from completed delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation Identity follows the envelope's filesystem context and actual case policy rather than lowercasing paths by OS name.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Set insertion hashes the identity text; envelope state lookup shares an
+ *   existing transaction or initializes native root identity on first use.
+ *   Uncached path resolution may observe aliases, ancestors and directory case
+ *   policy, so delegation is not constant work independent of spelling length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The servedFiles set records each served file once.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct served identities and their
+ *   text. A successfully proven new epoch clears it; generation retirement
+ *   leaves it collectible with the generation, without a separate native handle.
+ */
+export declare function markCachedSourceServed(
+/** Generation owning the served set and native identity transaction. */
+cached: TtscCachedProjectTransform, 
+/** Admitted native source spelling converted to the generation identity. */
+file: string): void;

package/lib/core/transform/validation/markCachedSourceServed.d.ts

@@ -0,0 +1,31 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/**
+ * Record a module after admitted output selection and watch notification.
+ *
+ * TransformTtsc also marks an admitted missing-output return, then hands the
+ * source back unchanged. For actual output it marks before constructing the
+ * final host value; this is a generation validation checkpoint, not a guarantee
+ * that downstream result construction or the host's delivery completed.
+ *
+ * @evidence contracts/common.md#principled-implementation The generation's path identity key records the caller's admitted selection checkpoint across equivalent spellings, enabling first-versus-later validation without claiming completed host delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns delivery-set insertion while transformTtsc owns successful selection timing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual transformTtsc call sites follow output selection or the typed missing-output continuation and completed watch notification; a mere cache hit or generic selection failure does not call this marker.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the admitted checkpoint, missing-output continuation and later host-result construction from completed delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation Identity follows the envelope's filesystem context and actual case policy rather than lowercasing paths by OS name.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Set insertion hashes the identity text; envelope state lookup shares an
+ *   existing transaction or initializes native root identity on first use.
+ *   Uncached path resolution may observe aliases, ancestors and directory case
+ *   policy, so delegation is not constant work independent of spelling length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The servedFiles set records each served file once.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct served identities and their
+ *   text. A successfully proven new epoch clears it; generation retirement
+ *   leaves it collectible with the generation, without a separate native handle.
+ */
+export declare function markCachedSourceServed(
+/** Generation owning the served set and native identity transaction. */
+cached: TtscCachedProjectTransform, 
+/** Admitted native source spelling converted to the generation identity. */
+file: string): void;

package/lib/core/transform/validation/markCachedSourceServed.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+
+/**
+ * Record a module after admitted output selection and watch notification.
+ *
+ * TransformTtsc also marks an admitted missing-output return, then hands the
+ * source back unchanged. For actual output it marks before constructing the
+ * final host value; this is a generation validation checkpoint, not a guarantee
+ * that downstream result construction or the host's delivery completed.
+ *
+ * @evidence contracts/common.md#principled-implementation The generation's path identity key records the caller's admitted selection checkpoint across equivalent spellings, enabling first-versus-later validation without claiming completed host delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns delivery-set insertion while transformTtsc owns successful selection timing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual transformTtsc call sites follow output selection or the typed missing-output continuation and completed watch notification; a mere cache hit or generic selection failure does not call this marker.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the admitted checkpoint, missing-output continuation and later host-result construction from completed delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation Identity follows the envelope's filesystem context and actual case policy rather than lowercasing paths by OS name.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Set insertion hashes the identity text; envelope state lookup shares an
+ *   existing transaction or initializes native root identity on first use.
+ *   Uncached path resolution may observe aliases, ancestors and directory case
+ *   policy, so delegation is not constant work independent of spelling length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The servedFiles set records each served file once.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct served identities and their
+ *   text. A successfully proven new epoch clears it; generation retirement
+ *   leaves it collectible with the generation, without a separate native handle.
+ */
+function markCachedSourceServed(
+/** Generation owning the served set and native identity transaction. */
+cached, 
+/** Admitted native source spelling converted to the generation identity. */
+file) {
+    (cached.servedFiles ??= new Set()).add(pathIdentityKey.pathIdentityKey(file, envelopeDerivation.envelopeDerivation(cached).identityContext));
+}
+
+exports.markCachedSourceServed = markCachedSourceServed;
+//# sourceMappingURL=markCachedSourceServed.js.map

package/lib/core/transform/validation/markCachedSourceServed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markCachedSourceServed.js","sources":["../../../../src/core/transform/validation/markCachedSourceServed.ts"],"sourcesContent":[null],"names":["pathIdentityKey","envelopeDerivation"],"mappings":";;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;SACa,sBAAsB;AACpC;AACA,MAAkC;AAClC;AACA,IAAY,EAAA;IAEZ,CAAC,MAAM,CAAC,WAAW,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CACpCA,+BAAe,CAAC,IAAI,EAAEC,qCAAkB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAClE;AACH;;;;"}

package/lib/core/transform/validation/markCachedSourceServed.mjs

@@ -0,0 +1,38 @@
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+
+/**
+ * Record a module after admitted output selection and watch notification.
+ *
+ * TransformTtsc also marks an admitted missing-output return, then hands the
+ * source back unchanged. For actual output it marks before constructing the
+ * final host value; this is a generation validation checkpoint, not a guarantee
+ * that downstream result construction or the host's delivery completed.
+ *
+ * @evidence contracts/common.md#principled-implementation The generation's path identity key records the caller's admitted selection checkpoint across equivalent spellings, enabling first-versus-later validation without claiming completed host delivery.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns delivery-set insertion while transformTtsc owns successful selection timing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual transformTtsc call sites follow output selection or the typed missing-output continuation and completed watch notification; a mere cache hit or generic selection failure does not call this marker.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the admitted checkpoint, missing-output continuation and later host-result construction from completed delivery.
+ * @evidence contracts/portability.md#os-neutral-implementation Identity follows the envelope's filesystem context and actual case policy rather than lowercasing paths by OS name.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Set insertion hashes the identity text; envelope state lookup shares an
+ *   existing transaction or initializes native root identity on first use.
+ *   Uncached path resolution may observe aliases, ancestors and directory case
+ *   policy, so delegation is not constant work independent of spelling length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The servedFiles set records each served file once.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct served identities and their
+ *   text. A successfully proven new epoch clears it; generation retirement
+ *   leaves it collectible with the generation, without a separate native handle.
+ */
+function markCachedSourceServed(
+/** Generation owning the served set and native identity transaction. */
+cached, 
+/** Admitted native source spelling converted to the generation identity. */
+file) {
+    (cached.servedFiles ??= new Set()).add(pathIdentityKey(file, envelopeDerivation(cached).identityContext));
+}
+
+export { markCachedSourceServed };
+//# sourceMappingURL=markCachedSourceServed.mjs.map

package/lib/core/transform/validation/markCachedSourceServed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"markCachedSourceServed.mjs","sources":["../../../../src/core/transform/validation/markCachedSourceServed.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;SACa,sBAAsB;AACpC;AACA,MAAkC;AAClC;AACA,IAAY,EAAA;IAEZ,CAAC,MAAM,CAAC,WAAW,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CACpC,eAAe,CAAC,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAClE;AACH;;;;"}