@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+
+/**
+ * Prove the universal inputs that were absent are still absent, through one
+ * native stat of the requested candidate. Groups retain the first missing
+ * component beneath the nearest directory; unqualified inputs retain their full
+ * exact paths.
+ *
+ * Unlike the entries half, this one rejects on an inability to prove: a
+ * permission or I/O failure certifies nothing about absence. That is the right
+ * answer for both narrow and complete proof: a recorded unavailable-content
+ * marker alone cannot distinguish absence from a newly present unreadable file.
+ * Complete validation still compares its recorded byte and membership
+ * populations after this independent native absence predicate holds.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact native ENOENT or ENOTDIR observations prove candidate absence, including native Unicode and short-name aliases. A vanished ancestor leaves descendants unreachable; replacement by a file rejects the grouped directory proof.
+ * @evidence contracts/common.md#clear-and-simple-design Missing-name validation has its own native absence boundary shared by narrow and complete proof; byte hashes and project membership remain separate predicates.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Listing inequality is not native name inequality; permission and transient failures are not fabricated absence. Only ENOENT and ENOTDIR qualify missing-path observations.
+ * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain inability-to-prove rejection, unreadable-content ambiguity and both caller routes before tags.
+ * @evidence contracts/portability.md#os-neutral-implementation The injected native stat resolves original candidate spelling, and its platform selects the same win32 or posix joining grammar as capture's ancestor probe. Case flags and JavaScript Unicode folding do not replace native alias resolution.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The pass borrows generation-owned groups and retains only each current native probe result; no directory listing, historical state or handle is acquired.
+ * @evidence contracts/performance.md#efficient-algorithms Each group checks its directory once, then each candidate requires one native stat. Work follows candidate count and native path resolution, without enumerating unrelated directory entries; exact probes are necessary because listing names cannot establish all native aliases.
+ * @evidence contracts/performance.md#reuse-equivalent-work Capture shares nearest-ancestor selection and raw candidate groups across consumers; each current absence proof must observe native candidates again unless the owning notification validator establishes unchanged inputs.
+ */
+function matchesUniversalHostInputProbes(cached, validation) {
+    const filesystem = resultFilesystem(cached.result);
+    const paths = (filesystem.platform ?? process.platform) === "win32"
+        ? path.win32
+        : path.posix;
+    for (const input of validation.directMissing ?? []) {
+        try {
+            filesystem.stat(input);
+            return false;
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                return false;
+        }
+    }
+    for (const [directory, names] of validation.missing) {
+        try {
+            if (!filesystem.stat(directory).isDirectory())
+                return false;
+        }
+        catch (error) {
+            // Only a provably absent/non-directory ancestor keeps every descendant
+            // unreachable. Permission and transient I/O failures cannot prove that
+            // a candidate is still missing, while replacing the proving directory
+            // with an exact file can itself redirect module resolution.
+            if (!isMissingPathError(error))
+                return false;
+            continue;
+        }
+        for (const name of names) {
+            try {
+                filesystem.stat(paths.join(directory, name));
+                return false;
+            }
+            catch (error) {
+                if (!isMissingPathError(error))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+/** True only for errors that prove a path cannot currently be traversed. */
+function isMissingPathError(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+
+export { matchesUniversalHostInputProbes };
+//# sourceMappingURL=matchesUniversalHostInputProbes.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputProbes.mjs","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputProbes.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,+BAA+B,CAC7C,MAAkC,EAClC,UAAmC,EAAA;IAEnC,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;AAClD,IAAA,MAAM,KAAK,GACT,CAAC,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,MAAM;UAC1C,IAAI,CAAC;AACP,UAAE,IAAI,CAAC,KAAK;IAChB,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,aAAa,IAAI,EAAE,EAAE;AAClD,QAAA,IAAI;AACF,YAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC;AACtB,YAAA,OAAO,KAAK;QACd;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;AAAE,gBAAA,OAAO,KAAK;QAC9C;IACF;IACA,KAAK,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE;AACnD,QAAA,IAAI;YACF,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE;AAAE,gBAAA,OAAO,KAAK;QAC7D;QAAE,OAAO,KAAK,EAAE;;;;;AAKd,YAAA,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;AAAE,gBAAA,OAAO,KAAK;YAC5C;QACF;AACA,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACxB,YAAA,IAAI;AACF,gBAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC5C,gBAAA,OAAO,KAAK;YACd;YAAE,OAAO,KAAK,EAAE;AACd,gBAAA,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;AAAE,oBAAA,OAAO,KAAK;YAC9C;QACF;IACF;AACA,IAAA,OAAO,IAAI;AACb;AAEA;AACA,SAAS,kBAAkB,CAAC,KAAc,EAAA;AACxC,IAAA,MAAM,IAAI,GAAI,KAA2C,EAAE,IAAI;AAC/D,IAAA,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,SAAS;AAChD;;;;"}

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.cjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.cjs";
+/**
+ * Whether every plugin source directory of a generation still holds the state
+ * its binary was built from, its files and the environment a build there runs
+ * in (samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * A directory whose tracker heard nothing below it has unchanged files, and is
+ * skipped while the environment it was last proven under is still this
+ * process's prepared reading (`PluginBuildEnvironmentReadings.cached`), which
+ * holds only while the Go tool, its environment file, and the C toolchain it
+ * names hold: the tracker watches the sources, not the toolchain outside them
+ * (samchon/ttsc#1516). Any other is proven by ttsc's rule
+ * (`pluginSourceHolds`), since no one path's metadata stands for the files
+ * below it. The proof lists the directory as the plugin build lists it, which a
+ * delivery pays only after an event below the directory, a changed environment,
+ * or where no tracker watches it or its watch cannot vouch for it, and reads
+ * the files' bytes again when population, metadata or fresh clock qualification
+ * does not permit digest reuse (`pluginSourceFilesDigest`). A missing or stale
+ * prepared environment reading returns false here. The async delivery owner
+ * prepares that authority before this synchronous proof; that prepared route
+ * never starts a cold Go or SDK probe on the host thread. Standalone
+ * synchronous results retain their original native observation and mismatch
+ * refresh; the async preparation owner marks its result identity.
+ *
+ * @param cached The generation being validated.
+ * @param validation Its universal-input manifest.
+ * @evidence contracts/common.md#principled-implementation Source state is qualified together with the Go build environment; tracker silence proves source files only, so changed environment requires the owning plugin-source proof.
+ * @evidence contracts/common.md#clear-and-simple-design One validator delegates binary-state semantics to ttsc and records the environment each successful tree proof saw.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A quiet source watcher cannot certify an external toolchain, and unreadable sources cannot become empty successful state.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
+ */
+export declare function matchesUniversalHostInputTrees(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.mjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.mjs";
+/**
+ * Whether every plugin source directory of a generation still holds the state
+ * its binary was built from, its files and the environment a build there runs
+ * in (samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * A directory whose tracker heard nothing below it has unchanged files, and is
+ * skipped while the environment it was last proven under is still this
+ * process's prepared reading (`PluginBuildEnvironmentReadings.cached`), which
+ * holds only while the Go tool, its environment file, and the C toolchain it
+ * names hold: the tracker watches the sources, not the toolchain outside them
+ * (samchon/ttsc#1516). Any other is proven by ttsc's rule
+ * (`pluginSourceHolds`), since no one path's metadata stands for the files
+ * below it. The proof lists the directory as the plugin build lists it, which a
+ * delivery pays only after an event below the directory, a changed environment,
+ * or where no tracker watches it or its watch cannot vouch for it, and reads
+ * the files' bytes again when population, metadata or fresh clock qualification
+ * does not permit digest reuse (`pluginSourceFilesDigest`). A missing or stale
+ * prepared environment reading returns false here. The async delivery owner
+ * prepares that authority before this synchronous proof; that prepared route
+ * never starts a cold Go or SDK probe on the host thread. Standalone
+ * synchronous results retain their original native observation and mismatch
+ * refresh; the async preparation owner marks its result identity.
+ *
+ * @param cached The generation being validated.
+ * @param validation Its universal-input manifest.
+ * @evidence contracts/common.md#principled-implementation Source state is qualified together with the Go build environment; tracker silence proves source files only, so changed environment requires the owning plugin-source proof.
+ * @evidence contracts/common.md#clear-and-simple-design One validator delegates binary-state semantics to ttsc and records the environment each successful tree proof saw.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A quiet source watcher cannot certify an external toolchain, and unreadable sources cannot become empty successful state.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
+ */
+export declare function matchesUniversalHostInputTrees(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,38 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation";
+/**
+ * Whether every plugin source directory of a generation still holds the state
+ * its binary was built from, its files and the environment a build there runs
+ * in (samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * A directory whose tracker heard nothing below it has unchanged files, and is
+ * skipped while the environment it was last proven under is still this
+ * process's prepared reading (`PluginBuildEnvironmentReadings.cached`), which
+ * holds only while the Go tool, its environment file, and the C toolchain it
+ * names hold: the tracker watches the sources, not the toolchain outside them
+ * (samchon/ttsc#1516). Any other is proven by ttsc's rule
+ * (`pluginSourceHolds`), since no one path's metadata stands for the files
+ * below it. The proof lists the directory as the plugin build lists it, which a
+ * delivery pays only after an event below the directory, a changed environment,
+ * or where no tracker watches it or its watch cannot vouch for it, and reads
+ * the files' bytes again when population, metadata or fresh clock qualification
+ * does not permit digest reuse (`pluginSourceFilesDigest`). A missing or stale
+ * prepared environment reading returns false here. The async delivery owner
+ * prepares that authority before this synchronous proof; that prepared route
+ * never starts a cold Go or SDK probe on the host thread. Standalone
+ * synchronous results retain their original native observation and mismatch
+ * refresh; the async preparation owner marks its result identity.
+ *
+ * @param cached The generation being validated.
+ * @param validation Its universal-input manifest.
+ * @evidence contracts/common.md#principled-implementation Source state is qualified together with the Go build environment; tracker silence proves source files only, so changed environment requires the owning plugin-source proof.
+ * @evidence contracts/common.md#clear-and-simple-design One validator delegates binary-state semantics to ttsc and records the environment each successful tree proof saw.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A quiet source watcher cannot certify an external toolchain, and unreadable sources cannot become empty successful state.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
+ */
+export declare function matchesUniversalHostInputTrees(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,66 @@
+'use strict';
+
+var pluginSource = require('ttsc/plugin-source');
+var resultFilesystem = require('../cache/resultFilesystem.js');
+var pluginSourceHolds = require('../inputs/pluginSourceHolds.js');
+var preparePluginBuildEnvironments = require('../inputs/preparePluginBuildEnvironments.js');
+var trackerProvesInputUnchanged = require('./trackerProvesInputUnchanged.js');
+
+/**
+ * Whether every plugin source directory of a generation still holds the state
+ * its binary was built from, its files and the environment a build there runs
+ * in (samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * A directory whose tracker heard nothing below it has unchanged files, and is
+ * skipped while the environment it was last proven under is still this
+ * process's prepared reading (`PluginBuildEnvironmentReadings.cached`), which
+ * holds only while the Go tool, its environment file, and the C toolchain it
+ * names hold: the tracker watches the sources, not the toolchain outside them
+ * (samchon/ttsc#1516). Any other is proven by ttsc's rule
+ * (`pluginSourceHolds`), since no one path's metadata stands for the files
+ * below it. The proof lists the directory as the plugin build lists it, which a
+ * delivery pays only after an event below the directory, a changed environment,
+ * or where no tracker watches it or its watch cannot vouch for it, and reads
+ * the files' bytes again when population, metadata or fresh clock qualification
+ * does not permit digest reuse (`pluginSourceFilesDigest`). A missing or stale
+ * prepared environment reading returns false here. The async delivery owner
+ * prepares that authority before this synchronous proof; that prepared route
+ * never starts a cold Go or SDK probe on the host thread. Standalone
+ * synchronous results retain their original native observation and mismatch
+ * refresh; the async preparation owner marks its result identity.
+ *
+ * @param cached The generation being validated.
+ * @param validation Its universal-input manifest.
+ * @evidence contracts/common.md#principled-implementation Source state is qualified together with the Go build environment; tracker silence proves source files only, so changed environment requires the owning plugin-source proof.
+ * @evidence contracts/common.md#clear-and-simple-design One validator delegates binary-state semantics to ttsc and records the environment each successful tree proof saw.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A quiet source watcher cannot certify an external toolchain, and unreadable sources cannot become empty successful state.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
+ */
+function matchesUniversalHostInputTrees(cached, validation, proof) {
+    for (const [directory, digest] of validation.trees) {
+        // Read before any proof, so the environment recorded below is one the
+        // proof saw or older, never a newer one it did not prove.
+        const prepared = preparePluginBuildEnvironments.usesPreparedPluginBuildEnvironments(cached.result);
+        const environment = prepared
+            ? proof?.cached === cached && proof.environments !== undefined
+                ? proof.environments.get(directory)
+                : pluginSource.PluginBuildEnvironmentReadings.cached(directory)
+            : pluginSource.processPluginBuildEnvironment(directory);
+        if (environment === undefined)
+            return false;
+        if (trackerProvesInputUnchanged.trackerProvesInputUnchanged(cached.hostInputMutationTracker, directory) &&
+            validation.treeEnvironments?.get(directory) === environment)
+            continue;
+        if (!pluginSourceHolds.pluginSourceHolds(directory, digest, resultFilesystem.resultFilesystem(cached.result), prepared ? { environment } : undefined))
+            return false;
+        (validation.treeEnvironments ??= new Map()).set(directory, environment);
+    }
+    return true;
+}
+
+exports.matchesUniversalHostInputTrees = matchesUniversalHostInputTrees;
+//# sourceMappingURL=matchesUniversalHostInputTrees.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputTrees.js","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputTrees.ts"],"sourcesContent":[null],"names":["usesPreparedPluginBuildEnvironments","PluginBuildEnvironmentReadings","processPluginBuildEnvironment","trackerProvesInputUnchanged","pluginSourceHolds","resultFilesystem"],"mappings":";;;;;;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,8BAA8B,CAC5C,MAAkC,EAClC,UAAmC,EACnC,KAAuC,EAAA;IAEvC,KAAK,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,UAAU,CAAC,KAAK,EAAE;;;QAGlD,MAAM,QAAQ,GAAGA,kEAAmC,CAAC,MAAM,CAAC,MAAM,CAAC;QACnE,MAAM,WAAW,GAAG;cAChB,KAAK,EAAE,MAAM,KAAK,MAAM,IAAI,KAAK,CAAC,YAAY,KAAK;kBACjD,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS;AAClC,kBAAEC,2CAA8B,CAAC,MAAM,CAAC,SAAS;AACnD,cAAEC,0CAA6B,CAAC,SAAS,CAAC;QAC5C,IAAI,WAAW,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;AAC3C,QAAA,IACEC,uDAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,SAAS,CAAC;YACvE,UAAU,CAAC,gBAAgB,EAAE,GAAG,CAAC,SAAS,CAAC,KAAK,WAAW;YAE3D;QACF,IACE,CAACC,mCAAiB,CAChB,SAAS,EACT,MAAM,EACNC,iCAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,EAC/B,QAAQ,GAAG,EAAE,WAAW,EAAE,GAAG,SAAS,CACvC;AAED,YAAA,OAAO,KAAK;AACd,QAAA,CAAC,UAAU,CAAC,gBAAgB,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,SAAS,EAAE,WAAW,CAAC;IACzE;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

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

@@ -0,0 +1,64 @@
+import { PluginBuildEnvironmentReadings, processPluginBuildEnvironment } from 'ttsc/plugin-source';
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { pluginSourceHolds } from '../inputs/pluginSourceHolds.mjs';
+import { usesPreparedPluginBuildEnvironments } from '../inputs/preparePluginBuildEnvironments.mjs';
+import { trackerProvesInputUnchanged } from './trackerProvesInputUnchanged.mjs';
+
+/**
+ * Whether every plugin source directory of a generation still holds the state
+ * its binary was built from, its files and the environment a build there runs
+ * in (samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * A directory whose tracker heard nothing below it has unchanged files, and is
+ * skipped while the environment it was last proven under is still this
+ * process's prepared reading (`PluginBuildEnvironmentReadings.cached`), which
+ * holds only while the Go tool, its environment file, and the C toolchain it
+ * names hold: the tracker watches the sources, not the toolchain outside them
+ * (samchon/ttsc#1516). Any other is proven by ttsc's rule
+ * (`pluginSourceHolds`), since no one path's metadata stands for the files
+ * below it. The proof lists the directory as the plugin build lists it, which a
+ * delivery pays only after an event below the directory, a changed environment,
+ * or where no tracker watches it or its watch cannot vouch for it, and reads
+ * the files' bytes again when population, metadata or fresh clock qualification
+ * does not permit digest reuse (`pluginSourceFilesDigest`). A missing or stale
+ * prepared environment reading returns false here. The async delivery owner
+ * prepares that authority before this synchronous proof; that prepared route
+ * never starts a cold Go or SDK probe on the host thread. Standalone
+ * synchronous results retain their original native observation and mismatch
+ * refresh; the async preparation owner marks its result identity.
+ *
+ * @param cached The generation being validated.
+ * @param validation Its universal-input manifest.
+ * @evidence contracts/common.md#principled-implementation Source state is qualified together with the Go build environment; tracker silence proves source files only, so changed environment requires the owning plugin-source proof.
+ * @evidence contracts/common.md#clear-and-simple-design One validator delegates binary-state semantics to ttsc and records the environment each successful tree proof saw.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A quiet source watcher cannot certify an external toolchain, and unreadable sources cannot become empty successful state.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
+ */
+function matchesUniversalHostInputTrees(cached, validation, proof) {
+    for (const [directory, digest] of validation.trees) {
+        // Read before any proof, so the environment recorded below is one the
+        // proof saw or older, never a newer one it did not prove.
+        const prepared = usesPreparedPluginBuildEnvironments(cached.result);
+        const environment = prepared
+            ? proof?.cached === cached && proof.environments !== undefined
+                ? proof.environments.get(directory)
+                : PluginBuildEnvironmentReadings.cached(directory)
+            : processPluginBuildEnvironment(directory);
+        if (environment === undefined)
+            return false;
+        if (trackerProvesInputUnchanged(cached.hostInputMutationTracker, directory) &&
+            validation.treeEnvironments?.get(directory) === environment)
+            continue;
+        if (!pluginSourceHolds(directory, digest, resultFilesystem(cached.result), prepared ? { environment } : undefined))
+            return false;
+        (validation.treeEnvironments ??= new Map()).set(directory, environment);
+    }
+    return true;
+}
+
+export { matchesUniversalHostInputTrees };
+//# sourceMappingURL=matchesUniversalHostInputTrees.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputTrees.mjs","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputTrees.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,8BAA8B,CAC5C,MAAkC,EAClC,UAAmC,EACnC,KAAuC,EAAA;IAEvC,KAAK,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,UAAU,CAAC,KAAK,EAAE;;;QAGlD,MAAM,QAAQ,GAAG,mCAAmC,CAAC,MAAM,CAAC,MAAM,CAAC;QACnE,MAAM,WAAW,GAAG;cAChB,KAAK,EAAE,MAAM,KAAK,MAAM,IAAI,KAAK,CAAC,YAAY,KAAK;kBACjD,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS;AAClC,kBAAE,8BAA8B,CAAC,MAAM,CAAC,SAAS;AACnD,cAAE,6BAA6B,CAAC,SAAS,CAAC;QAC5C,IAAI,WAAW,KAAK,SAAS;AAAE,YAAA,OAAO,KAAK;AAC3C,QAAA,IACE,2BAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,SAAS,CAAC;YACvE,UAAU,CAAC,gBAAgB,EAAE,GAAG,CAAC,SAAS,CAAC,KAAK,WAAW;YAE3D;QACF,IACE,CAAC,iBAAiB,CAChB,SAAS,EACT,MAAM,EACN,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,EAC/B,QAAQ,GAAG,EAAE,WAAW,EAAE,GAAG,SAAS,CACvC;AAED,YAAA,OAAO,KAAK;AACd,QAAA,CAAC,UAAU,CAAC,gBAAgB,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,SAAS,EAAE,WAAW,CAAC;IACzE;AACA,IAAA,OAAO,IAAI;AACb;;;;"}

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.cjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.cjs";
+/**
+ * Validate universal descriptor/config inputs. Versioned native config
+ * predicates are replayed before notification shortcuts; other proven inputs
+ * retain reuse. Existing paths use the generation's native metadata manifest;
+ * missing probes are grouped by the nearest existing directory and checked
+ * through native candidate stats so alternate spellings cannot hide an existing
+ * input.
+ *
+ * While the tracker proves every input the manifest covers unchanged, source
+ * content is not read; plugin build environments still require their own
+ * identity check. Otherwise each input is proven on its own: an entry or a
+ * plugin source its tracker proves is skipped, and the rest are read. One input
+ * a watch cannot prove, a plugin source outside the project on macOS, whose
+ * stream no probe proves delivered (samchon/ttsc#1453), used to send every
+ * universal input back to the disk on every delivery.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact healthy notifications qualify covered source spellings, while tree environment checks remain mandatory because external build authority is independent of native source events.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator combines existing-entry, missing-name and tree authority without duplicating their native observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source watcher silence cannot replace toolchain/environment identity; failed or unproved scopes fall back to their owning validators.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs separate source-content reuse, mandatory environment checks and per-input fallback rather than claiming notifications eliminate every observation.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ */
+export declare function matchesUniversalHostInputs(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.mjs";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation.mjs";
+/**
+ * Validate universal descriptor/config inputs. Versioned native config
+ * predicates are replayed before notification shortcuts; other proven inputs
+ * retain reuse. Existing paths use the generation's native metadata manifest;
+ * missing probes are grouped by the nearest existing directory and checked
+ * through native candidate stats so alternate spellings cannot hide an existing
+ * input.
+ *
+ * While the tracker proves every input the manifest covers unchanged, source
+ * content is not read; plugin build environments still require their own
+ * identity check. Otherwise each input is proven on its own: an entry or a
+ * plugin source its tracker proves is skipped, and the rest are read. One input
+ * a watch cannot prove, a plugin source outside the project on macOS, whose
+ * stream no probe proves delivered (samchon/ttsc#1453), used to send every
+ * universal input back to the disk on every delivery.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact healthy notifications qualify covered source spellings, while tree environment checks remain mandatory because external build authority is independent of native source events.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator combines existing-entry, missing-name and tree authority without duplicating their native observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source watcher silence cannot replace toolchain/environment identity; failed or unproved scopes fall back to their owning validators.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs separate source-content reuse, mandatory environment checks and per-input fallback rather than claiming notifications eliminate every observation.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ */
+export declare function matchesUniversalHostInputs(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,29 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
+import type { TtscHostInputValidation } from "./TtscHostInputValidation";
+/**
+ * Validate universal descriptor/config inputs. Versioned native config
+ * predicates are replayed before notification shortcuts; other proven inputs
+ * retain reuse. Existing paths use the generation's native metadata manifest;
+ * missing probes are grouped by the nearest existing directory and checked
+ * through native candidate stats so alternate spellings cannot hide an existing
+ * input.
+ *
+ * While the tracker proves every input the manifest covers unchanged, source
+ * content is not read; plugin build environments still require their own
+ * identity check. Otherwise each input is proven on its own: an entry or a
+ * plugin source its tracker proves is skipped, and the rest are read. One input
+ * a watch cannot prove, a plugin source outside the project on macOS, whose
+ * stream no probe proves delivered (samchon/ttsc#1453), used to send every
+ * universal input back to the disk on every delivery.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact healthy notifications qualify covered source spellings, while tree environment checks remain mandatory because external build authority is independent of native source events.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator combines existing-entry, missing-name and tree authority without duplicating their native observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source watcher silence cannot replace toolchain/environment identity; failed or unproved scopes fall back to their owning validators.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs separate source-content reuse, mandatory environment checks and per-input fallback rather than claiming notifications eliminate every observation.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ */
+export declare function matchesUniversalHostInputs(cached: TtscCachedProjectTransform, validation: TtscHostInputValidation, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,52 @@
+'use strict';
+
+var matchesUniversalHostInputEntries = require('./matchesUniversalHostInputEntries.js');
+var matchesUniversalHostInputProbes = require('./matchesUniversalHostInputProbes.js');
+var matchesUniversalHostInputTrees = require('./matchesUniversalHostInputTrees.js');
+var nativeInputPredicatesHold = require('./nativeInputPredicatesHold.js');
+var trackerProvesInputUnchanged = require('./trackerProvesInputUnchanged.js');
+
+/**
+ * Validate universal descriptor/config inputs. Versioned native config
+ * predicates are replayed before notification shortcuts; other proven inputs
+ * retain reuse. Existing paths use the generation's native metadata manifest;
+ * missing probes are grouped by the nearest existing directory and checked
+ * through native candidate stats so alternate spellings cannot hide an existing
+ * input.
+ *
+ * While the tracker proves every input the manifest covers unchanged, source
+ * content is not read; plugin build environments still require their own
+ * identity check. Otherwise each input is proven on its own: an entry or a
+ * plugin source its tracker proves is skipped, and the rest are read. One input
+ * a watch cannot prove, a plugin source outside the project on macOS, whose
+ * stream no probe proves delivered (samchon/ttsc#1453), used to send every
+ * universal input back to the disk on every delivery.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact healthy notifications qualify covered source spellings, while tree environment checks remain mandatory because external build authority is independent of native source events.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator combines existing-entry, missing-name and tree authority without duplicating their native observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source watcher silence cannot replace toolchain/environment identity; failed or unproved scopes fall back to their owning validators.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs separate source-content reuse, mandatory environment checks and per-input fallback rather than claiming notifications eliminate every observation.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ */
+function matchesUniversalHostInputs(cached, validation, proof) {
+    if (!nativeInputPredicatesHold.nativeInputPredicatesHold(cached, proof))
+        return false;
+    let notificationsProveAll = true;
+    for (const input of validation.covered) {
+        if (!trackerProvesInputUnchanged.trackerProvesInputUnchanged(cached.hostInputMutationTracker, input)) {
+            notificationsProveAll = false;
+            break;
+        }
+    }
+    if (notificationsProveAll)
+        return matchesUniversalHostInputTrees.matchesUniversalHostInputTrees(cached, validation, proof);
+    return (matchesUniversalHostInputEntries.matchesUniversalHostInputEntries(cached, validation) &&
+        matchesUniversalHostInputProbes.matchesUniversalHostInputProbes(cached, validation) &&
+        matchesUniversalHostInputTrees.matchesUniversalHostInputTrees(cached, validation, proof));
+}
+
+exports.matchesUniversalHostInputs = matchesUniversalHostInputs;
+//# sourceMappingURL=matchesUniversalHostInputs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputs.js","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputs.ts"],"sourcesContent":[null],"names":["nativeInputPredicatesHold","trackerProvesInputUnchanged","matchesUniversalHostInputTrees","matchesUniversalHostInputEntries","matchesUniversalHostInputProbes"],"mappings":";;;;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;SACa,0BAA0B,CACxC,MAAkC,EAClC,UAAmC,EACnC,KAAuC,EAAA;AAEvC,IAAA,IAAI,CAACA,mDAAyB,CAAC,MAAM,EAAE,KAAK,CAAC;AAAE,QAAA,OAAO,KAAK;IAC3D,IAAI,qBAAqB,GAAG,IAAI;AAChC,IAAA,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,OAAO,EAAE;QACtC,IAAI,CAACC,uDAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,KAAK,CAAC,EAAE;YACxE,qBAAqB,GAAG,KAAK;YAC7B;QACF;IACF;AACA,IAAA,IAAI,qBAAqB;QACvB,OAAOC,6DAA8B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;AAClE,IAAA,QACEC,iEAAgC,CAAC,MAAM,EAAE,UAAU,CAAC;AACpD,QAAAC,+DAA+B,CAAC,MAAM,EAAE,UAAU,CAAC;QACnDF,6DAA8B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;AAE7D;;;;"}

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

@@ -0,0 +1,50 @@
+import { matchesUniversalHostInputEntries } from './matchesUniversalHostInputEntries.mjs';
+import { matchesUniversalHostInputProbes } from './matchesUniversalHostInputProbes.mjs';
+import { matchesUniversalHostInputTrees } from './matchesUniversalHostInputTrees.mjs';
+import { nativeInputPredicatesHold } from './nativeInputPredicatesHold.mjs';
+import { trackerProvesInputUnchanged } from './trackerProvesInputUnchanged.mjs';
+
+/**
+ * Validate universal descriptor/config inputs. Versioned native config
+ * predicates are replayed before notification shortcuts; other proven inputs
+ * retain reuse. Existing paths use the generation's native metadata manifest;
+ * missing probes are grouped by the nearest existing directory and checked
+ * through native candidate stats so alternate spellings cannot hide an existing
+ * input.
+ *
+ * While the tracker proves every input the manifest covers unchanged, source
+ * content is not read; plugin build environments still require their own
+ * identity check. Otherwise each input is proven on its own: an entry or a
+ * plugin source its tracker proves is skipped, and the rest are read. One input
+ * a watch cannot prove, a plugin source outside the project on macOS, whose
+ * stream no probe proves delivered (samchon/ttsc#1453), used to send every
+ * universal input back to the disk on every delivery.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact healthy notifications qualify covered source spellings, while tree environment checks remain mandatory because external build authority is independent of native source events.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator combines existing-entry, missing-name and tree authority without duplicating their native observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source watcher silence cannot replace toolchain/environment identity; failed or unproved scopes fall back to their owning validators.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs separate source-content reuse, mandatory environment checks and per-input fallback rather than claiming notifications eliminate every observation.
+ * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
+ * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ */
+function matchesUniversalHostInputs(cached, validation, proof) {
+    if (!nativeInputPredicatesHold(cached, proof))
+        return false;
+    let notificationsProveAll = true;
+    for (const input of validation.covered) {
+        if (!trackerProvesInputUnchanged(cached.hostInputMutationTracker, input)) {
+            notificationsProveAll = false;
+            break;
+        }
+    }
+    if (notificationsProveAll)
+        return matchesUniversalHostInputTrees(cached, validation, proof);
+    return (matchesUniversalHostInputEntries(cached, validation) &&
+        matchesUniversalHostInputProbes(cached, validation) &&
+        matchesUniversalHostInputTrees(cached, validation, proof));
+}
+
+export { matchesUniversalHostInputs };
+//# sourceMappingURL=matchesUniversalHostInputs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputs.mjs","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;SACa,0BAA0B,CACxC,MAAkC,EAClC,UAAmC,EACnC,KAAuC,EAAA;AAEvC,IAAA,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,KAAK,CAAC;AAAE,QAAA,OAAO,KAAK;IAC3D,IAAI,qBAAqB,GAAG,IAAI;AAChC,IAAA,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,OAAO,EAAE;QACtC,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,wBAAwB,EAAE,KAAK,CAAC,EAAE;YACxE,qBAAqB,GAAG,KAAK;YAC7B;QACF;IACF;AACA,IAAA,IAAI,qBAAqB;QACvB,OAAO,8BAA8B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;AAClE,IAAA,QACE,gCAAgC,CAAC,MAAM,EAAE,UAAU,CAAC;AACpD,QAAA,+BAA+B,CAAC,MAAM,EAAE,UAAU,CAAC;QACnD,8BAA8B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;AAE7D;;;;"}

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

@@ -0,0 +1,18 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.cjs";
+/**
+ * Validate every generation-owned native config predicate before cache reuse.
+ * This check also applies when notification/epoch shortcuts admit other inputs.
+ * A generation with no native predicates requires no native replay context;
+ * existing non-native proof owners still perform their own validation.
+ *
+ * @evidence contracts/common.md#principled-implementation Every recorded native predicate must match through the generation's original filesystem view. An empty native predicate population contributes no native constraint, without admitting other proof domains or converting an exception into reuse.
+ * @evidence contracts/common.md#clear-and-simple-design One gate is shared by source, complete-snapshot and universal-input admission; the typed replay owns encodings and native errors.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Metadata and notification shortcuts cannot omit typed config predicates or repair an unstable producer witness.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies generation ownership and the admission shortcuts that must retain this gate.
+ * @evidence contracts/portability.md#os-neutral-implementation Relative names are resolved against the recorded project with the filesystem view's path dialect; native identity and encoding belong to the replay operation.
+ * @evidence contracts/performance.md#efficient-algorithms Immutable observation membership is indexed once, including an empty population. Each new synchronous admission replays only indexed native predicates and stops at the first refusal; nested validators share its verdict without another scan or native query. Empty populations require no native replay context.
+ * @evidence contracts/performance.md#reuse-equivalent-work A weak observation index shares immutable membership. Current verdicts belong only to an exact-owner synchronous transaction, never the next delivery or an await.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The weak index follows immutable observation lifetime; synchronous verdicts and native queries acquire no handle or history.
+ */
+export declare function nativeInputPredicatesHold(cached: TtscCachedProjectTransform, proof?: TtscGenerationProof.Transaction): boolean;

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

@@ -0,0 +1,18 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscGenerationProof } from "./TtscGenerationProof.mjs";
+/**
+ * Validate every generation-owned native config predicate before cache reuse.
+ * This check also applies when notification/epoch shortcuts admit other inputs.
+ * A generation with no native predicates requires no native replay context;
+ * existing non-native proof owners still perform their own validation.
+ *
+ * @evidence contracts/common.md#principled-implementation Every recorded native predicate must match through the generation's original filesystem view. An empty native predicate population contributes no native constraint, without admitting other proof domains or converting an exception into reuse.
+ * @evidence contracts/common.md#clear-and-simple-design One gate is shared by source, complete-snapshot and universal-input admission; the typed replay owns encodings and native errors.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Metadata and notification shortcuts cannot omit typed config predicates or repair an unstable producer witness.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies generation ownership and the admission shortcuts that must retain this gate.
+ * @evidence contracts/portability.md#os-neutral-implementation Relative names are resolved against the recorded project with the filesystem view's path dialect; native identity and encoding belong to the replay operation.
+ * @evidence contracts/performance.md#efficient-algorithms Immutable observation membership is indexed once, including an empty population. Each new synchronous admission replays only indexed native predicates and stops at the first refusal; nested validators share its verdict without another scan or native query. Empty populations require no native replay context.
+ * @evidence contracts/performance.md#reuse-equivalent-work A weak observation index shares immutable membership. Current verdicts belong only to an exact-owner synchronous transaction, never the next delivery or an await.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The weak index follows immutable observation lifetime; synchronous verdicts and native queries acquire no handle or history.
+ */
+export declare function nativeInputPredicatesHold(cached: TtscCachedProjectTransform, proof?: TtscGenerationProof.Transaction): boolean;