@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,77 @@
+'use strict';
+
+var path = require('node:path');
+var resultFilesystem = require('../cache/resultFilesystem.js');
+
+/**
+ * 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.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";
+}
+
+exports.matchesUniversalHostInputProbes = matchesUniversalHostInputProbes;
+//# sourceMappingURL=matchesUniversalHostInputProbes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matchesUniversalHostInputProbes.js","sources":["../../../../src/core/transform/validation/matchesUniversalHostInputProbes.ts"],"sourcesContent":[null],"names":["resultFilesystem"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,+BAA+B,CAC7C,MAAkC,EAClC,UAAmC,EAAA;IAEnC,MAAM,UAAU,GAAGA,iCAAgB,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/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,37 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.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 Each tree first 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): boolean;

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

@@ -0,0 +1,37 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.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 Each tree first 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): boolean;

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

@@ -0,0 +1,37 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+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 Each tree first 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): boolean;

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

@@ -0,0 +1,64 @@
+'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 Each tree first 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) {
+    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
+            ? 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":";;;;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,8BAA8B,CAC5C,MAAkC,EAClC,UAAmC,EAAA;IAEnC,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;AAClB,cAAEC,2CAA8B,CAAC,MAAM,CAAC,SAAS;AACjD,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,62 @@
+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 Each tree first 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) {
+    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
+            ? 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":";;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,8BAA8B,CAC5C,MAAkC,EAClC,UAAmC,EAAA;IAEnC,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;AAClB,cAAE,8BAA8B,CAAC,MAAM,CAAC,SAAS;AACjD,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,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.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 predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  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): boolean;

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

@@ -0,0 +1,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.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 predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  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): boolean;

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

@@ -0,0 +1,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+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 predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  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): 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 predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  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) {
+    if (!nativeInputPredicatesHold.nativeInputPredicatesHold(cached))
+        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);
+    return (matchesUniversalHostInputEntries.matchesUniversalHostInputEntries(cached, validation) &&
+        matchesUniversalHostInputProbes.matchesUniversalHostInputProbes(cached, validation) &&
+        matchesUniversalHostInputTrees.matchesUniversalHostInputTrees(cached, validation));
+}
+
+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":";;;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,0BAA0B,CACxC,MAAkC,EAClC,UAAmC,EAAA;AAEnC,IAAA,IAAI,CAACA,mDAAyB,CAAC,MAAM,CAAC;AAAE,QAAA,OAAO,KAAK;IACpD,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;AACvB,QAAA,OAAOC,6DAA8B,CAAC,MAAM,EAAE,UAAU,CAAC;AAC3D,IAAA,QACEC,iEAAgC,CAAC,MAAM,EAAE,UAAU,CAAC;AACpD,QAAAC,+DAA+B,CAAC,MAAM,EAAE,UAAU,CAAC;AACnD,QAAAF,6DAA8B,CAAC,MAAM,EAAE,UAAU,CAAC;AAEtD;;;;"}