@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/envelope/isVolatileFile.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var collectDeclaredIdentities = require('./collectDeclaredIdentities.js');
+var derivationIdentity = require('./derivationIdentity.js');
+
+/**
+ * Report whether the plugin declared `file` volatile: its output depends on
+ * non-file inputs (environment, time, network), so neither the project
+ * transform cache nor a bundler's persistent cache may replay it. Reads the
+ * per-envelope identity set instead of rescanning the member list.
+ *
+ * @evidence contracts/common.md#principled-implementation Volatility is explicit producer membership by file identity, not an inference from output contents; an exception result supplies no declaration for this predicate.
+ * @evidence contracts/common.md#clear-and-simple-design The predicate reads the declaration while cache and bundler owners enforce their respective replay restrictions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unsupported non-file dependencies are honestly represented by volatility rather than replaced by fixture hashes or a promise that file inputs prove them stable.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-file inputs and both replay consequences, along with per-envelope set reuse; separated tags follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration and queried file share the envelope's native filesystem identity context, so relative/absolute aliases and filesystem case behavior are not hand-normalized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The set retains only declared physical identities on weakly owned generation state and opens no watcher or file handle; its lifetime ends with that state.
+ * @evidence contracts/performance.md#efficient-algorithms One linear declaration fold builds a set; subsequent module queries use keyed membership and memoized path identity instead of repeated whole-list scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work The memoized set is valid for the immutable declaration, project root and identity context of one envelope generation; unrelated result objects cannot share it.
+ */
+function isVolatileFile(state, props) {
+    if (props.result.type === "exception") {
+        return false;
+    }
+    const declared = (state.volatileFiles ??= collectDeclaredIdentities.collectDeclaredIdentities(state, props.projectRoot, props.result.volatile));
+    return declared.has(derivationIdentity.derivationIdentity(state, props.file));
+}
+
+exports.isVolatileFile = isVolatileFile;
+//# sourceMappingURL=isVolatileFile.js.map

package/lib/core/transform/envelope/isVolatileFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isVolatileFile.js","sources":["../../../../src/core/transform/envelope/isVolatileFile.ts"],"sourcesContent":[null],"names":["collectDeclaredIdentities","derivationIdentity"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;AAcG;AACG,SAAU,cAAc,CAC5B,KAA6B,EAC7B,KAIC,EAAA;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;AACrC,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,IAAI,KAAK,CAAC,aAAa,KAAKA,mDAAyB,CACjE,KAAK,EACL,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,MAAM,CAAC,QAAQ,CACtB,CAAC;AACF,IAAA,OAAO,QAAQ,CAAC,GAAG,CAACC,qCAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;"}

package/lib/core/transform/envelope/isVolatileFile.mjs

@@ -0,0 +1,28 @@
+import { collectDeclaredIdentities } from './collectDeclaredIdentities.mjs';
+import { derivationIdentity } from './derivationIdentity.mjs';
+
+/**
+ * Report whether the plugin declared `file` volatile: its output depends on
+ * non-file inputs (environment, time, network), so neither the project
+ * transform cache nor a bundler's persistent cache may replay it. Reads the
+ * per-envelope identity set instead of rescanning the member list.
+ *
+ * @evidence contracts/common.md#principled-implementation Volatility is explicit producer membership by file identity, not an inference from output contents; an exception result supplies no declaration for this predicate.
+ * @evidence contracts/common.md#clear-and-simple-design The predicate reads the declaration while cache and bundler owners enforce their respective replay restrictions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unsupported non-file dependencies are honestly represented by volatility rather than replaced by fixture hashes or a promise that file inputs prove them stable.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains non-file inputs and both replay consequences, along with per-envelope set reuse; separated tags follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration and queried file share the envelope's native filesystem identity context, so relative/absolute aliases and filesystem case behavior are not hand-normalized.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The set retains only declared physical identities on weakly owned generation state and opens no watcher or file handle; its lifetime ends with that state.
+ * @evidence contracts/performance.md#efficient-algorithms One linear declaration fold builds a set; subsequent module queries use keyed membership and memoized path identity instead of repeated whole-list scans.
+ * @evidence contracts/performance.md#reuse-equivalent-work The memoized set is valid for the immutable declaration, project root and identity context of one envelope generation; unrelated result objects cannot share it.
+ */
+function isVolatileFile(state, props) {
+    if (props.result.type === "exception") {
+        return false;
+    }
+    const declared = (state.volatileFiles ??= collectDeclaredIdentities(state, props.projectRoot, props.result.volatile));
+    return declared.has(derivationIdentity(state, props.file));
+}
+
+export { isVolatileFile };
+//# sourceMappingURL=isVolatileFile.mjs.map

package/lib/core/transform/envelope/isVolatileFile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isVolatileFile.mjs","sources":["../../../../src/core/transform/envelope/isVolatileFile.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;AAcG;AACG,SAAU,cAAc,CAC5B,KAA6B,EAC7B,KAIC,EAAA;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;AACrC,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,IAAI,KAAK,CAAC,aAAa,KAAK,yBAAyB,CACjE,KAAK,EACL,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,MAAM,CAAC,QAAQ,CACtB,CAAC;AACF,IAAA,OAAO,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;"}

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.d.cts

@@ -0,0 +1,31 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Reproduce the compiler producer's legacy hash/realpath projection.
+ *
+ * Successful reads supply content identity and known directories supply the
+ * directory sentinel, both requiring a successful realpath. A known file
+ * without successful content cannot supply a complete legacy proof. Otherwise a
+ * negative predicate projects to null as the producer does; that lossy value
+ * does not establish generic path absence. Rich predicates must still be
+ * replayed.
+ *
+ * @evidence contracts/common.md#principled-implementation Branch order matches inputObservationFS.proof in the Go producer so paired rich/legacy records can be checked for producer consistency; null projection is lossy and cannot replace exact predicate replay.
+ * @evidence contracts/common.md#clear-and-simple-design This pure adapter owns only producer encoding; normalization, cross-predicate compatibility and live filesystem comparison remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker is the supported legacy encoding and missing content/realpath stays an explicit failure; the adapter does not invent a content digest from a positive file predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain successful projections, incomplete file proof and the negative-predicate null limitation, with separate acknowledgment tags following the documentation skill.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Maps recorded predicate results to the producer's legacy encoding in memory; the realpath it carries is passed through as recorded.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function legacyProjectionOfGraphInputObservation(observation: ITtscCompilerTransformation.IInputObservation): {
+    failure?: undefined;
+    hash: string | null;
+    realpath: string | null;
+} | {
+    failure: string;
+};

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.d.mts

@@ -0,0 +1,31 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Reproduce the compiler producer's legacy hash/realpath projection.
+ *
+ * Successful reads supply content identity and known directories supply the
+ * directory sentinel, both requiring a successful realpath. A known file
+ * without successful content cannot supply a complete legacy proof. Otherwise a
+ * negative predicate projects to null as the producer does; that lossy value
+ * does not establish generic path absence. Rich predicates must still be
+ * replayed.
+ *
+ * @evidence contracts/common.md#principled-implementation Branch order matches inputObservationFS.proof in the Go producer so paired rich/legacy records can be checked for producer consistency; null projection is lossy and cannot replace exact predicate replay.
+ * @evidence contracts/common.md#clear-and-simple-design This pure adapter owns only producer encoding; normalization, cross-predicate compatibility and live filesystem comparison remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker is the supported legacy encoding and missing content/realpath stays an explicit failure; the adapter does not invent a content digest from a positive file predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain successful projections, incomplete file proof and the negative-predicate null limitation, with separate acknowledgment tags following the documentation skill.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Maps recorded predicate results to the producer's legacy encoding in memory; the realpath it carries is passed through as recorded.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function legacyProjectionOfGraphInputObservation(observation: ITtscCompilerTransformation.IInputObservation): {
+    failure?: undefined;
+    hash: string | null;
+    realpath: string | null;
+} | {
+    failure: string;
+};

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.d.ts

@@ -0,0 +1,31 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Reproduce the compiler producer's legacy hash/realpath projection.
+ *
+ * Successful reads supply content identity and known directories supply the
+ * directory sentinel, both requiring a successful realpath. A known file
+ * without successful content cannot supply a complete legacy proof. Otherwise a
+ * negative predicate projects to null as the producer does; that lossy value
+ * does not establish generic path absence. Rich predicates must still be
+ * replayed.
+ *
+ * @evidence contracts/common.md#principled-implementation Branch order matches inputObservationFS.proof in the Go producer so paired rich/legacy records can be checked for producer consistency; null projection is lossy and cannot replace exact predicate replay.
+ * @evidence contracts/common.md#clear-and-simple-design This pure adapter owns only producer encoding; normalization, cross-predicate compatibility and live filesystem comparison remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker is the supported legacy encoding and missing content/realpath stays an explicit failure; the adapter does not invent a content digest from a positive file predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain successful projections, incomplete file proof and the negative-predicate null limitation, with separate acknowledgment tags following the documentation skill.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Maps recorded predicate results to the producer's legacy encoding in memory; the realpath it carries is passed through as recorded.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function legacyProjectionOfGraphInputObservation(observation: ITtscCompilerTransformation.IInputObservation): {
+    failure?: undefined;
+    hash: string | null;
+    realpath: string | null;
+} | {
+    failure: string;
+};

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var hashText = require('../utils/hashText.js');
+
+/**
+ * Reproduce the compiler producer's legacy hash/realpath projection.
+ *
+ * Successful reads supply content identity and known directories supply the
+ * directory sentinel, both requiring a successful realpath. A known file
+ * without successful content cannot supply a complete legacy proof. Otherwise a
+ * negative predicate projects to null as the producer does; that lossy value
+ * does not establish generic path absence. Rich predicates must still be
+ * replayed.
+ *
+ * @evidence contracts/common.md#principled-implementation Branch order matches inputObservationFS.proof in the Go producer so paired rich/legacy records can be checked for producer consistency; null projection is lossy and cannot replace exact predicate replay.
+ * @evidence contracts/common.md#clear-and-simple-design This pure adapter owns only producer encoding; normalization, cross-predicate compatibility and live filesystem comparison remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker is the supported legacy encoding and missing content/realpath stays an explicit failure; the adapter does not invent a content digest from a positive file predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain successful projections, incomplete file proof and the negative-predicate null limitation, with separate acknowledgment tags following the documentation skill.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Maps recorded predicate results to the producer's legacy encoding in memory; the realpath it carries is passed through as recorded.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function legacyProjectionOfGraphInputObservation(observation) {
+    if (observation.readFile?.ok === true) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: observation.readFile.hash,
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const directory = observation.stat === "directory" || observation.directoryExists === true;
+    if (directory) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: hashText.hashText("ttsc:host-input:directory\0"),
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const file = observation.stat === "file" || observation.fileExists === true;
+    if (file) {
+        return { failure: "content-unavailable" };
+    }
+    const missing = observation.stat === "missing" ||
+        observation.fileExists === false ||
+        observation.directoryExists === false ||
+        observation.readFile?.ok === false;
+    return missing
+        ? { hash: null, realpath: null }
+        : { failure: "unsupported-input-kind" };
+}
+
+exports.legacyProjectionOfGraphInputObservation = legacyProjectionOfGraphInputObservation;
+//# sourceMappingURL=legacyProjectionOfGraphInputObservation.js.map

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyProjectionOfGraphInputObservation.js","sources":["../../../../src/core/transform/envelope/legacyProjectionOfGraphInputObservation.ts"],"sourcesContent":[null],"names":["hashText"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,uCAAuC,CACrD,WAA0D,EAAA;IAI1D,IAAI,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,IAAI,EAAE;AACrC,QAAA,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK;AAClC,cAAE;AACE,gBAAA,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AAC/B,gBAAA,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AACpC;AACH,cAAE,EAAE,OAAO,EAAE,sBAAsB,EAAE;IACzC;AACA,IAAA,MAAM,SAAS,GACb,WAAW,CAAC,IAAI,KAAK,WAAW,IAAI,WAAW,CAAC,eAAe,KAAK,IAAI;IAC1E,IAAI,SAAS,EAAE;AACb,QAAA,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK;AAClC,cAAE;AACE,gBAAA,IAAI,EAAEA,iBAAQ,CAAC,6BAA6B,CAAC;AAC7C,gBAAA,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AACpC;AACH,cAAE,EAAE,OAAO,EAAE,sBAAsB,EAAE;IACzC;AACA,IAAA,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,KAAK,MAAM,IAAI,WAAW,CAAC,UAAU,KAAK,IAAI;IAC3E,IAAI,IAAI,EAAE;AACR,QAAA,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE;IAC3C;AACA,IAAA,MAAM,OAAO,GACX,WAAW,CAAC,IAAI,KAAK,SAAS;QAC9B,WAAW,CAAC,UAAU,KAAK,KAAK;QAChC,WAAW,CAAC,eAAe,KAAK,KAAK;AACrC,QAAA,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,KAAK;AACpC,IAAA,OAAO;UACH,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI;AAC9B,UAAE,EAAE,OAAO,EAAE,wBAAwB,EAAE;AAC3C;;;;"}

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.mjs

@@ -0,0 +1,58 @@
+import { hashText } from '../utils/hashText.mjs';
+
+/**
+ * Reproduce the compiler producer's legacy hash/realpath projection.
+ *
+ * Successful reads supply content identity and known directories supply the
+ * directory sentinel, both requiring a successful realpath. A known file
+ * without successful content cannot supply a complete legacy proof. Otherwise a
+ * negative predicate projects to null as the producer does; that lossy value
+ * does not establish generic path absence. Rich predicates must still be
+ * replayed.
+ *
+ * @evidence contracts/common.md#principled-implementation Branch order matches inputObservationFS.proof in the Go producer so paired rich/legacy records can be checked for producer consistency; null projection is lossy and cannot replace exact predicate replay.
+ * @evidence contracts/common.md#clear-and-simple-design This pure adapter owns only producer encoding; normalization, cross-predicate compatibility and live filesystem comparison remain separate operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker is the supported legacy encoding and missing content/realpath stays an explicit failure; the adapter does not invent a content digest from a positive file predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain successful projections, incomplete file proof and the negative-predicate null limitation, with separate acknowledgment tags following the documentation skill.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Maps recorded predicate results to the producer's legacy encoding in memory; the realpath it carries is passed through as recorded.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   No loop or traversal of its own; constant work apart from delegated
+ *   calls.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function legacyProjectionOfGraphInputObservation(observation) {
+    if (observation.readFile?.ok === true) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: observation.readFile.hash,
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const directory = observation.stat === "directory" || observation.directoryExists === true;
+    if (directory) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: hashText("ttsc:host-input:directory\0"),
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const file = observation.stat === "file" || observation.fileExists === true;
+    if (file) {
+        return { failure: "content-unavailable" };
+    }
+    const missing = observation.stat === "missing" ||
+        observation.fileExists === false ||
+        observation.directoryExists === false ||
+        observation.readFile?.ok === false;
+    return missing
+        ? { hash: null, realpath: null }
+        : { failure: "unsupported-input-kind" };
+}
+
+export { legacyProjectionOfGraphInputObservation };
+//# sourceMappingURL=legacyProjectionOfGraphInputObservation.mjs.map

package/lib/core/transform/envelope/legacyProjectionOfGraphInputObservation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyProjectionOfGraphInputObservation.mjs","sources":["../../../../src/core/transform/envelope/legacyProjectionOfGraphInputObservation.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,uCAAuC,CACrD,WAA0D,EAAA;IAI1D,IAAI,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,IAAI,EAAE;AACrC,QAAA,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK;AAClC,cAAE;AACE,gBAAA,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AAC/B,gBAAA,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AACpC;AACH,cAAE,EAAE,OAAO,EAAE,sBAAsB,EAAE;IACzC;AACA,IAAA,MAAM,SAAS,GACb,WAAW,CAAC,IAAI,KAAK,WAAW,IAAI,WAAW,CAAC,eAAe,KAAK,IAAI;IAC1E,IAAI,SAAS,EAAE;AACb,QAAA,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK;AAClC,cAAE;AACE,gBAAA,IAAI,EAAE,QAAQ,CAAC,6BAA6B,CAAC;AAC7C,gBAAA,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;AACpC;AACH,cAAE,EAAE,OAAO,EAAE,sBAAsB,EAAE;IACzC;AACA,IAAA,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,KAAK,MAAM,IAAI,WAAW,CAAC,UAAU,KAAK,IAAI;IAC3E,IAAI,IAAI,EAAE;AACR,QAAA,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE;IAC3C;AACA,IAAA,MAAM,OAAO,GACX,WAAW,CAAC,IAAI,KAAK,SAAS;QAC9B,WAAW,CAAC,UAAU,KAAK,KAAK;QAChC,WAAW,CAAC,eAAe,KAAK,KAAK;AACrC,QAAA,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,KAAK;AACpC,IAAA,OAAO;UACH,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI;AAC9B,UAAE,EAAE,OAAO,EAAE,wBAAwB,EAAE;AAC3C;;;;"}

package/lib/core/transform/envelope/mergeGraphInputObservations.d.cts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Join normalized duplicate lexical keys only when repeated predicates agree.
+ *
+ * Normalization fixes object member order before structural comparison. List
+ * order remains part of the recorded directory observation, and the merged
+ * record must also satisfy cross-predicate compatibility. Undefined marks a
+ * conflict; it does not mean that the path was absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Repeated compiler predicates must serialize identically; native predicates retain distinct kind/scope entries only while same-kind witnesses agree, after which cross-predicate compatibility rejects contradictory combinations. Independent predicate records merge without replacing either input.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns duplicate observation union; normalization, permanent conflict indexing, legacy projection and native replay remain separate boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting predicate or listing values return no merged proof; a later predicate cannot silently repair the earlier contradictory observation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies normalized inputs, significant listing order and conflict versus absence, without claiming live filesystem agreement.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares normalized recorded predicate values in memory; native path grammar, identity resolution and live observation belong to the producer and validator.
+ * @evidence contracts/performance.md#efficient-algorithms Six compiler predicates are compared, followed by a native kind/scope union with pairwise same-kind consistency checks and deterministic sorting. The native union costs quadratic predicate comparisons and linear retained records. Work and temporary strings follow repeated listing and path payload bytes, not just predicate count; no native input is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combines this duplicate pair without storing a memo or certifying reuse of native observations across captures.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a shallow merged record borrowing nested predicate values or no result; the envelope index owns retained lists and conflicts, and this operation acquires no resource or historical state.
+ */
+export declare function mergeGraphInputObservations(left: ITtscCompilerTransformation.IInputObservation, right: ITtscCompilerTransformation.IInputObservation): ITtscCompilerTransformation.IInputObservation | undefined;

package/lib/core/transform/envelope/mergeGraphInputObservations.d.mts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Join normalized duplicate lexical keys only when repeated predicates agree.
+ *
+ * Normalization fixes object member order before structural comparison. List
+ * order remains part of the recorded directory observation, and the merged
+ * record must also satisfy cross-predicate compatibility. Undefined marks a
+ * conflict; it does not mean that the path was absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Repeated compiler predicates must serialize identically; native predicates retain distinct kind/scope entries only while same-kind witnesses agree, after which cross-predicate compatibility rejects contradictory combinations. Independent predicate records merge without replacing either input.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns duplicate observation union; normalization, permanent conflict indexing, legacy projection and native replay remain separate boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting predicate or listing values return no merged proof; a later predicate cannot silently repair the earlier contradictory observation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies normalized inputs, significant listing order and conflict versus absence, without claiming live filesystem agreement.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares normalized recorded predicate values in memory; native path grammar, identity resolution and live observation belong to the producer and validator.
+ * @evidence contracts/performance.md#efficient-algorithms Six compiler predicates are compared, followed by a native kind/scope union with pairwise same-kind consistency checks and deterministic sorting. The native union costs quadratic predicate comparisons and linear retained records. Work and temporary strings follow repeated listing and path payload bytes, not just predicate count; no native input is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combines this duplicate pair without storing a memo or certifying reuse of native observations across captures.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a shallow merged record borrowing nested predicate values or no result; the envelope index owns retained lists and conflicts, and this operation acquires no resource or historical state.
+ */
+export declare function mergeGraphInputObservations(left: ITtscCompilerTransformation.IInputObservation, right: ITtscCompilerTransformation.IInputObservation): ITtscCompilerTransformation.IInputObservation | undefined;

package/lib/core/transform/envelope/mergeGraphInputObservations.d.ts

@@ -0,0 +1,19 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Join normalized duplicate lexical keys only when repeated predicates agree.
+ *
+ * Normalization fixes object member order before structural comparison. List
+ * order remains part of the recorded directory observation, and the merged
+ * record must also satisfy cross-predicate compatibility. Undefined marks a
+ * conflict; it does not mean that the path was absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Repeated compiler predicates must serialize identically; native predicates retain distinct kind/scope entries only while same-kind witnesses agree, after which cross-predicate compatibility rejects contradictory combinations. Independent predicate records merge without replacing either input.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns duplicate observation union; normalization, permanent conflict indexing, legacy projection and native replay remain separate boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting predicate or listing values return no merged proof; a later predicate cannot silently repair the earlier contradictory observation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies normalized inputs, significant listing order and conflict versus absence, without claiming live filesystem agreement.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares normalized recorded predicate values in memory; native path grammar, identity resolution and live observation belong to the producer and validator.
+ * @evidence contracts/performance.md#efficient-algorithms Six compiler predicates are compared, followed by a native kind/scope union with pairwise same-kind consistency checks and deterministic sorting. The native union costs quadratic predicate comparisons and linear retained records. Work and temporary strings follow repeated listing and path payload bytes, not just predicate count; no native input is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combines this duplicate pair without storing a memo or certifying reuse of native observations across captures.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a shallow merged record borrowing nested predicate values or no result; the envelope index owns retained lists and conflicts, and this operation acquires no resource or historical state.
+ */
+export declare function mergeGraphInputObservations(left: ITtscCompilerTransformation.IInputObservation, right: ITtscCompilerTransformation.IInputObservation): ITtscCompilerTransformation.IInputObservation | undefined;

package/lib/core/transform/envelope/mergeGraphInputObservations.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var graphInputObservationCompatible = require('./graphInputObservationCompatible.js');
+
+/**
+ * Join normalized duplicate lexical keys only when repeated predicates agree.
+ *
+ * Normalization fixes object member order before structural comparison. List
+ * order remains part of the recorded directory observation, and the merged
+ * record must also satisfy cross-predicate compatibility. Undefined marks a
+ * conflict; it does not mean that the path was absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Repeated compiler predicates must serialize identically; native predicates retain distinct kind/scope entries only while same-kind witnesses agree, after which cross-predicate compatibility rejects contradictory combinations. Independent predicate records merge without replacing either input.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns duplicate observation union; normalization, permanent conflict indexing, legacy projection and native replay remain separate boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting predicate or listing values return no merged proof; a later predicate cannot silently repair the earlier contradictory observation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies normalized inputs, significant listing order and conflict versus absence, without claiming live filesystem agreement.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares normalized recorded predicate values in memory; native path grammar, identity resolution and live observation belong to the producer and validator.
+ * @evidence contracts/performance.md#efficient-algorithms Six compiler predicates are compared, followed by a native kind/scope union with pairwise same-kind consistency checks and deterministic sorting. The native union costs quadratic predicate comparisons and linear retained records. Work and temporary strings follow repeated listing and path payload bytes, not just predicate count; no native input is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combines this duplicate pair without storing a memo or certifying reuse of native observations across captures.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a shallow merged record borrowing nested predicate values or no result; the envelope index owns retained lists and conflicts, and this operation acquires no resource or historical state.
+ */
+function mergeGraphInputObservations(left, right) {
+    for (const property of [
+        "accessibleEntries",
+        "directoryExists",
+        "fileExists",
+        "readFile",
+        "realpath",
+        "stat",
+    ]) {
+        if (left[property] !== undefined &&
+            right[property] !== undefined &&
+            JSON.stringify(left[property]) !== JSON.stringify(right[property])) {
+            return undefined;
+        }
+    }
+    const native = new Map();
+    for (const predicate of [
+        ...(left.nativePredicates ?? []),
+        ...(right.nativePredicates ?? []),
+    ]) {
+        for (const prior of native.values()) {
+            if (prior.kind === predicate.kind &&
+                (prior.version !== predicate.version ||
+                    prior.digest !== predicate.digest ||
+                    prior.identityStable !== predicate.identityStable ||
+                    prior.realpath !== predicate.realpath))
+                return undefined;
+        }
+        native.set(predicate.kind + ":" + predicate.scope, predicate);
+    }
+    const merged = {
+        ...left,
+        ...right,
+        ...(native.size === 0
+            ? {}
+            : {
+                nativePredicates: [...native.values()].sort((a, b) => (a.kind + ":" + a.scope).localeCompare(b.kind + ":" + b.scope)),
+            }),
+    };
+    return graphInputObservationCompatible.graphInputObservationCompatible(merged) ? merged : undefined;
+}
+
+exports.mergeGraphInputObservations = mergeGraphInputObservations;
+//# sourceMappingURL=mergeGraphInputObservations.js.map

package/lib/core/transform/envelope/mergeGraphInputObservations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeGraphInputObservations.js","sources":["../../../../src/core/transform/envelope/mergeGraphInputObservations.ts"],"sourcesContent":[null],"names":["graphInputObservationCompatible"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,2BAA2B,CACzC,IAAmD,EACnD,KAAoD,EAAA;IAEpD,KAAK,MAAM,QAAQ,IAAI;QACrB,mBAAmB;QACnB,iBAAiB;QACjB,YAAY;QACZ,UAAU;QACV,UAAU;QACV,MAAM;AACE,KAAA,EAAE;AACV,QAAA,IACE,IAAI,CAAC,QAAQ,CAAC,KAAK,SAAS;AAC5B,YAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,SAAS;AAC7B,YAAA,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAClE;AACA,YAAA,OAAO,SAAS;QAClB;IACF;AACA,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAKnB;IACH,KAAK,MAAM,SAAS,IAAI;AACtB,QAAA,IAAI,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC;AAChC,QAAA,IAAI,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAC;AAClC,KAAA,EAAE;QACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE;AACnC,YAAA,IACE,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI;AAC7B,iBAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,OAAO;AAClC,oBAAA,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM;AACjC,oBAAA,KAAK,CAAC,cAAc,KAAK,SAAS,CAAC,cAAc;AACjD,oBAAA,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,CAAC;AAExC,gBAAA,OAAO,SAAS;QACpB;AACA,QAAA,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC;IAC/D;AACA,IAAA,MAAM,MAAM,GAAG;AACb,QAAA,GAAG,IAAI;AACP,QAAA,GAAG,KAAK;AACR,QAAA,IAAI,MAAM,CAAC,IAAI,KAAK;AAClB,cAAE;AACF,cAAE;AACE,gBAAA,gBAAgB,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAC/C,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAC/D;aACF,CAAC;KACP;AACD,IAAA,OAAOA,+DAA+B,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS;AACrE;;;;"}

package/lib/core/transform/envelope/mergeGraphInputObservations.mjs

@@ -0,0 +1,63 @@
+import { graphInputObservationCompatible } from './graphInputObservationCompatible.mjs';
+
+/**
+ * Join normalized duplicate lexical keys only when repeated predicates agree.
+ *
+ * Normalization fixes object member order before structural comparison. List
+ * order remains part of the recorded directory observation, and the merged
+ * record must also satisfy cross-predicate compatibility. Undefined marks a
+ * conflict; it does not mean that the path was absent.
+ *
+ * @evidence contracts/common.md#principled-implementation Repeated compiler predicates must serialize identically; native predicates retain distinct kind/scope entries only while same-kind witnesses agree, after which cross-predicate compatibility rejects contradictory combinations. Independent predicate records merge without replacing either input.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns duplicate observation union; normalization, permanent conflict indexing, legacy projection and native replay remain separate boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Conflicting predicate or listing values return no merged proof; a later predicate cannot silently repair the earlier contradictory observation.
+ * @evidence contracts/common.md#meaningful-documentation Native prose specifies normalized inputs, significant listing order and conflict versus absence, without claiming live filesystem agreement.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares normalized recorded predicate values in memory; native path grammar, identity resolution and live observation belong to the producer and validator.
+ * @evidence contracts/performance.md#efficient-algorithms Six compiler predicates are compared, followed by a native kind/scope union with pairwise same-kind consistency checks and deterministic sorting. The native union costs quadratic predicate comparisons and linear retained records. Work and temporary strings follow repeated listing and path payload bytes, not just predicate count; no native input is read.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Combines this duplicate pair without storing a memo or certifying reuse of native observations across captures.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a shallow merged record borrowing nested predicate values or no result; the envelope index owns retained lists and conflicts, and this operation acquires no resource or historical state.
+ */
+function mergeGraphInputObservations(left, right) {
+    for (const property of [
+        "accessibleEntries",
+        "directoryExists",
+        "fileExists",
+        "readFile",
+        "realpath",
+        "stat",
+    ]) {
+        if (left[property] !== undefined &&
+            right[property] !== undefined &&
+            JSON.stringify(left[property]) !== JSON.stringify(right[property])) {
+            return undefined;
+        }
+    }
+    const native = new Map();
+    for (const predicate of [
+        ...(left.nativePredicates ?? []),
+        ...(right.nativePredicates ?? []),
+    ]) {
+        for (const prior of native.values()) {
+            if (prior.kind === predicate.kind &&
+                (prior.version !== predicate.version ||
+                    prior.digest !== predicate.digest ||
+                    prior.identityStable !== predicate.identityStable ||
+                    prior.realpath !== predicate.realpath))
+                return undefined;
+        }
+        native.set(predicate.kind + ":" + predicate.scope, predicate);
+    }
+    const merged = {
+        ...left,
+        ...right,
+        ...(native.size === 0
+            ? {}
+            : {
+                nativePredicates: [...native.values()].sort((a, b) => (a.kind + ":" + a.scope).localeCompare(b.kind + ":" + b.scope)),
+            }),
+    };
+    return graphInputObservationCompatible(merged) ? merged : undefined;
+}
+
+export { mergeGraphInputObservations };
+//# sourceMappingURL=mergeGraphInputObservations.mjs.map

package/lib/core/transform/envelope/mergeGraphInputObservations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeGraphInputObservations.mjs","sources":["../../../../src/core/transform/envelope/mergeGraphInputObservations.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,2BAA2B,CACzC,IAAmD,EACnD,KAAoD,EAAA;IAEpD,KAAK,MAAM,QAAQ,IAAI;QACrB,mBAAmB;QACnB,iBAAiB;QACjB,YAAY;QACZ,UAAU;QACV,UAAU;QACV,MAAM;AACE,KAAA,EAAE;AACV,QAAA,IACE,IAAI,CAAC,QAAQ,CAAC,KAAK,SAAS;AAC5B,YAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,SAAS;AAC7B,YAAA,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAClE;AACA,YAAA,OAAO,SAAS;QAClB;IACF;AACA,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAKnB;IACH,KAAK,MAAM,SAAS,IAAI;AACtB,QAAA,IAAI,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC;AAChC,QAAA,IAAI,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAC;AAClC,KAAA,EAAE;QACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE;AACnC,YAAA,IACE,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI;AAC7B,iBAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,OAAO;AAClC,oBAAA,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM;AACjC,oBAAA,KAAK,CAAC,cAAc,KAAK,SAAS,CAAC,cAAc;AACjD,oBAAA,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,CAAC;AAExC,gBAAA,OAAO,SAAS;QACpB;AACA,QAAA,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC;IAC/D;AACA,IAAA,MAAM,MAAM,GAAG;AACb,QAAA,GAAG,IAAI;AACP,QAAA,GAAG,KAAK;AACR,QAAA,IAAI,MAAM,CAAC,IAAI,KAAK;AAClB,cAAE;AACF,cAAE;AACE,gBAAA,gBAAgB,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAC/C,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAC/D;aACF,CAAC;KACP;AACD,IAAA,OAAO,+BAA+B,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,SAAS;AACrE;;;;"}

package/lib/core/transform/envelope/normalizeGraphInputObservation.d.cts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Normalize one untrusted predicate proof without filling missing predicates.
+ *
+ * Malformed, empty or contradictory records return undefined. Present directory
+ * lists require a string in every slot and are copied. Successful read hashes
+ * must be lowercase SHA-256 text, and successful realpaths must be absolute in
+ * the producer's platform semantics. Unknown fields are ignored; absent
+ * supported predicates remain unknown.
+ *
+ * @evidence contracts/common.md#principled-implementation Own-property checks distinguish an omitted predicate from an explicit result, schema checks establish supported value shapes, and compatibility rejects contradictory normalized states without adding new observations.
+ * @evidence contracts/common.md#clear-and-simple-design Parsing produces one detached observation and delegates cross-predicate meaning to graphInputObservationCompatible, keeping host filesystem replay outside this boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Protocol hash syntax and absolute-realpath checks validate genuine producer data; neither missing predicates nor malformed evidence receive fabricated values.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain undefined outcomes, copied lists, hash form, platform interpretation and unknown versus absent fields with documentation-skill paragraph and tag separation.
+ * @evidence contracts/portability.md#os-neutral-implementation The declared producer platform chooses realpath parsing and resolution, while the host platform is only the default; native case behavior is not inferred or rewritten by this structural parser.
+ * @evidence contracts/performance.md#efficient-algorithms Each native predicate is validated/copied once with a kind/scope uniqueness Set; work includes digest/path text and retained predicate count. Each of E entry-list slots is validated and copied in one indexed traversal; missing slots yield undefined rather than being skipped. Hash syntax and producer-path normalization add work proportional to their supplied text, while other predicate fields are fixed in number. Temporary space is O(E) copied string references plus normalized path text; immutable entry strings are shared, not reread from the filesystem.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeGraphInputObservation(value: unknown, platform?: NodeJS.Platform): ITtscCompilerTransformation.IInputObservation | undefined;

package/lib/core/transform/envelope/normalizeGraphInputObservation.d.mts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Normalize one untrusted predicate proof without filling missing predicates.
+ *
+ * Malformed, empty or contradictory records return undefined. Present directory
+ * lists require a string in every slot and are copied. Successful read hashes
+ * must be lowercase SHA-256 text, and successful realpaths must be absolute in
+ * the producer's platform semantics. Unknown fields are ignored; absent
+ * supported predicates remain unknown.
+ *
+ * @evidence contracts/common.md#principled-implementation Own-property checks distinguish an omitted predicate from an explicit result, schema checks establish supported value shapes, and compatibility rejects contradictory normalized states without adding new observations.
+ * @evidence contracts/common.md#clear-and-simple-design Parsing produces one detached observation and delegates cross-predicate meaning to graphInputObservationCompatible, keeping host filesystem replay outside this boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Protocol hash syntax and absolute-realpath checks validate genuine producer data; neither missing predicates nor malformed evidence receive fabricated values.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain undefined outcomes, copied lists, hash form, platform interpretation and unknown versus absent fields with documentation-skill paragraph and tag separation.
+ * @evidence contracts/portability.md#os-neutral-implementation The declared producer platform chooses realpath parsing and resolution, while the host platform is only the default; native case behavior is not inferred or rewritten by this structural parser.
+ * @evidence contracts/performance.md#efficient-algorithms Each native predicate is validated/copied once with a kind/scope uniqueness Set; work includes digest/path text and retained predicate count. Each of E entry-list slots is validated and copied in one indexed traversal; missing slots yield undefined rather than being skipped. Hash syntax and producer-path normalization add work proportional to their supplied text, while other predicate fields are fixed in number. Temporary space is O(E) copied string references plus normalized path text; immutable entry strings are shared, not reread from the filesystem.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeGraphInputObservation(value: unknown, platform?: NodeJS.Platform): ITtscCompilerTransformation.IInputObservation | undefined;

package/lib/core/transform/envelope/normalizeGraphInputObservation.d.ts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+/**
+ * Normalize one untrusted predicate proof without filling missing predicates.
+ *
+ * Malformed, empty or contradictory records return undefined. Present directory
+ * lists require a string in every slot and are copied. Successful read hashes
+ * must be lowercase SHA-256 text, and successful realpaths must be absolute in
+ * the producer's platform semantics. Unknown fields are ignored; absent
+ * supported predicates remain unknown.
+ *
+ * @evidence contracts/common.md#principled-implementation Own-property checks distinguish an omitted predicate from an explicit result, schema checks establish supported value shapes, and compatibility rejects contradictory normalized states without adding new observations.
+ * @evidence contracts/common.md#clear-and-simple-design Parsing produces one detached observation and delegates cross-predicate meaning to graphInputObservationCompatible, keeping host filesystem replay outside this boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Protocol hash syntax and absolute-realpath checks validate genuine producer data; neither missing predicates nor malformed evidence receive fabricated values.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain undefined outcomes, copied lists, hash form, platform interpretation and unknown versus absent fields with documentation-skill paragraph and tag separation.
+ * @evidence contracts/portability.md#os-neutral-implementation The declared producer platform chooses realpath parsing and resolution, while the host platform is only the default; native case behavior is not inferred or rewritten by this structural parser.
+ * @evidence contracts/performance.md#efficient-algorithms Each native predicate is validated/copied once with a kind/scope uniqueness Set; work includes digest/path text and retained predicate count. Each of E entry-list slots is validated and copied in one indexed traversal; missing slots yield undefined rather than being skipped. Hash syntax and producer-path normalization add work proportional to their supplied text, while other predicate fields are fixed in number. Temporary space is O(E) copied string references plus normalized path text; immutable entry strings are shared, not reread from the filesystem.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+export declare function normalizeGraphInputObservation(value: unknown, platform?: NodeJS.Platform): ITtscCompilerTransformation.IInputObservation | undefined;