@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/watch/projectMembershipInput.d.mts

@@ -0,0 +1,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscWatchInput } from "./TtscWatchInput.mjs";
+/**
+ * The watch input for a generation's root-file membership, or `undefined` for a
+ * generation that recorded no project walk (samchon/ttsc#1419).
+ *
+ * The compiler reports what it observed while building the program, and the
+ * `include` expansion that decides the root files is not among it: the adapter
+ * decides membership itself, through the project walk. So a file the tsconfig
+ * includes, such as a new global declaration, changed no watch input a host
+ * had, and a watching host never re-ran the modules whose generated code it
+ * changes. This input carries that membership to the host: its path is the
+ * project root, and its evidence is the walk's digest, every directory the walk
+ * entered, and the policy it applied.
+ *
+ * Built once per recorded directory list, so every module of a generation hands
+ * the host the same object.
+ *
+ * @evidence contracts/common.md#principled-implementation The root path carries the adapter's actual membership digest, directory population and walk policy, expressing root-file selection rather than equating it with one compiler input hash.
+ * @evidence contracts/common.md#clear-and-simple-design One optional carrier represents a recorded project walk, with a memo keyed by generation and the recorded directory-list reference.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A generation without a recorded walk returns undefined rather than inventing a default membership result from its root name.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership ownership, absent walks and reference reuse, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Root identity comes from the generation's native context and directory spellings retain the walk's observed policy rather than relying on an OS-wide case model.
+ * @evidence contracts/performance.md#efficient-algorithms Missing directory state returns immediately and a matching list needs only keyed/reference access. Construction additionally resolves root identity through the generation context, scans all D records, sorts relevant directory pairs, serializes/hashes policy and selected text, then maps all D directory paths. Native cold observations, path/key text and digest temporary arrays/encoding costs remain included; no new project walk occurs.
+ * @evidence contracts/performance.md#reuse-equivalent-work The weak memo shares by generation and directory-array identity, requiring immutable policy/entries, fixed root and a valid generation native identity view. A replacement list rebuilds the carrier, and callers must not mutate shared evidence; array identity alone does not establish those premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The memo retains one current directory-list reference and membership carrier per generation, including D path references, policy reference, digest and native identity text. Replacement drops the owner's previous entry; borrowers can retain earlier carriers, policies or lists. Weak keys do not keep generations alive, but provide no byte cap on these payloads. No watcher or descriptor is acquired here.
+ */
+export declare function projectMembershipInput(cached: TtscCachedProjectTransform): TtscWatchInput | undefined;

package/lib/core/transform/watch/projectMembershipInput.d.ts

@@ -0,0 +1,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscWatchInput } from "./TtscWatchInput";
+/**
+ * The watch input for a generation's root-file membership, or `undefined` for a
+ * generation that recorded no project walk (samchon/ttsc#1419).
+ *
+ * The compiler reports what it observed while building the program, and the
+ * `include` expansion that decides the root files is not among it: the adapter
+ * decides membership itself, through the project walk. So a file the tsconfig
+ * includes, such as a new global declaration, changed no watch input a host
+ * had, and a watching host never re-ran the modules whose generated code it
+ * changes. This input carries that membership to the host: its path is the
+ * project root, and its evidence is the walk's digest, every directory the walk
+ * entered, and the policy it applied.
+ *
+ * Built once per recorded directory list, so every module of a generation hands
+ * the host the same object.
+ *
+ * @evidence contracts/common.md#principled-implementation The root path carries the adapter's actual membership digest, directory population and walk policy, expressing root-file selection rather than equating it with one compiler input hash.
+ * @evidence contracts/common.md#clear-and-simple-design One optional carrier represents a recorded project walk, with a memo keyed by generation and the recorded directory-list reference.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A generation without a recorded walk returns undefined rather than inventing a default membership result from its root name.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership ownership, absent walks and reference reuse, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Root identity comes from the generation's native context and directory spellings retain the walk's observed policy rather than relying on an OS-wide case model.
+ * @evidence contracts/performance.md#efficient-algorithms Missing directory state returns immediately and a matching list needs only keyed/reference access. Construction additionally resolves root identity through the generation context, scans all D records, sorts relevant directory pairs, serializes/hashes policy and selected text, then maps all D directory paths. Native cold observations, path/key text and digest temporary arrays/encoding costs remain included; no new project walk occurs.
+ * @evidence contracts/performance.md#reuse-equivalent-work The weak memo shares by generation and directory-array identity, requiring immutable policy/entries, fixed root and a valid generation native identity view. A replacement list rebuilds the carrier, and callers must not mutate shared evidence; array identity alone does not establish those premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The memo retains one current directory-list reference and membership carrier per generation, including D path references, policy reference, digest and native identity text. Replacement drops the owner's previous entry; borrowers can retain earlier carriers, policies or lists. Weak keys do not keep generations alive, but provide no byte cap on these payloads. No watcher or descriptor is acquired here.
+ */
+export declare function projectMembershipInput(cached: TtscCachedProjectTransform): TtscWatchInput | undefined;

package/lib/core/transform/watch/projectMembershipInput.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var projectMembershipDigest = require('../project/projectMembershipDigest.js');
+
+/** One membership input per generation, shared by every module it serves. */
+const PROJECT_MEMBERSHIP_INPUTS = new WeakMap();
+/**
+ * The watch input for a generation's root-file membership, or `undefined` for a
+ * generation that recorded no project walk (samchon/ttsc#1419).
+ *
+ * The compiler reports what it observed while building the program, and the
+ * `include` expansion that decides the root files is not among it: the adapter
+ * decides membership itself, through the project walk. So a file the tsconfig
+ * includes, such as a new global declaration, changed no watch input a host
+ * had, and a watching host never re-ran the modules whose generated code it
+ * changes. This input carries that membership to the host: its path is the
+ * project root, and its evidence is the walk's digest, every directory the walk
+ * entered, and the policy it applied.
+ *
+ * Built once per recorded directory list, so every module of a generation hands
+ * the host the same object.
+ *
+ * @evidence contracts/common.md#principled-implementation The root path carries the adapter's actual membership digest, directory population and walk policy, expressing root-file selection rather than equating it with one compiler input hash.
+ * @evidence contracts/common.md#clear-and-simple-design One optional carrier represents a recorded project walk, with a memo keyed by generation and the recorded directory-list reference.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A generation without a recorded walk returns undefined rather than inventing a default membership result from its root name.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership ownership, absent walks and reference reuse, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Root identity comes from the generation's native context and directory spellings retain the walk's observed policy rather than relying on an OS-wide case model.
+ * @evidence contracts/performance.md#efficient-algorithms Missing directory state returns immediately and a matching list needs only keyed/reference access. Construction additionally resolves root identity through the generation context, scans all D records, sorts relevant directory pairs, serializes/hashes policy and selected text, then maps all D directory paths. Native cold observations, path/key text and digest temporary arrays/encoding costs remain included; no new project walk occurs.
+ * @evidence contracts/performance.md#reuse-equivalent-work The weak memo shares by generation and directory-array identity, requiring immutable policy/entries, fixed root and a valid generation native identity view. A replacement list rebuilds the carrier, and callers must not mutate shared evidence; array identity alone does not establish those premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The memo retains one current directory-list reference and membership carrier per generation, including D path references, policy reference, digest and native identity text. Replacement drops the owner's previous entry; borrowers can retain earlier carriers, policies or lists. Weak keys do not keep generations alive, but provide no byte cap on these payloads. No watcher or descriptor is acquired here.
+ */
+function projectMembershipInput(cached) {
+    const directories = cached.projectDirectories;
+    if (directories === undefined)
+        return undefined;
+    const memo = PROJECT_MEMBERSHIP_INPUTS.get(cached);
+    if (memo !== undefined && memo.directories === directories) {
+        return memo.input;
+    }
+    const input = {
+        evidence: {
+            identity: pathIdentityKey.pathIdentityKey(cached.projectRoot, envelopeDerivation.envelopeDerivation(cached).identityContext),
+            missing: false,
+            state: {
+                codec: "membership",
+                digest: projectMembershipDigest.projectMembershipDigest(cached.membershipPolicy, directories),
+                directories: directories.map((directory) => directory.path),
+                policy: cached.membershipPolicy,
+            },
+        },
+        file: cached.projectRoot,
+    };
+    PROJECT_MEMBERSHIP_INPUTS.set(cached, { directories, input });
+    return input;
+}
+
+exports.projectMembershipInput = projectMembershipInput;
+//# sourceMappingURL=projectMembershipInput.js.map

package/lib/core/transform/watch/projectMembershipInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectMembershipInput.js","sources":["../../../../src/core/transform/watch/projectMembershipInput.ts"],"sourcesContent":[null],"names":["pathIdentityKey","envelopeDerivation","projectMembershipDigest"],"mappings":";;;;;;AAMA;AACA,MAAM,yBAAyB,GAAG,IAAI,OAAO,EAG1C;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,sBAAsB,CACpC,MAAkC,EAAA;AAElC,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,kBAAkB;IAC7C,IAAI,WAAW,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IAC/C,MAAM,IAAI,GAAG,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC;IAClD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,EAAE;QAC1D,OAAO,IAAI,CAAC,KAAK;IACnB;AACA,IAAA,MAAM,KAAK,GAAmB;AAC5B,QAAA,QAAQ,EAAE;AACR,YAAA,QAAQ,EAAEA,+BAAe,CACvB,MAAM,CAAC,WAAW,EAClBC,qCAAkB,CAAC,MAAM,CAAC,CAAC,eAAe,CAC3C;AACD,YAAA,OAAO,EAAE,KAAK;AACd,YAAA,KAAK,EAAE;AACL,gBAAA,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAEC,+CAAuB,CAAC,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC;AACrE,gBAAA,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,IAAI,CAAC;gBAC3D,MAAM,EAAE,MAAM,CAAC,gBAAgB;AAChC,aAAA;AACF,SAAA;QACD,IAAI,EAAE,MAAM,CAAC,WAAW;KACzB;IACD,yBAAyB,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAC7D,IAAA,OAAO,KAAK;AACd;;;;"}

package/lib/core/transform/watch/projectMembershipInput.mjs

@@ -0,0 +1,58 @@
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { projectMembershipDigest } from '../project/projectMembershipDigest.mjs';
+
+/** One membership input per generation, shared by every module it serves. */
+const PROJECT_MEMBERSHIP_INPUTS = new WeakMap();
+/**
+ * The watch input for a generation's root-file membership, or `undefined` for a
+ * generation that recorded no project walk (samchon/ttsc#1419).
+ *
+ * The compiler reports what it observed while building the program, and the
+ * `include` expansion that decides the root files is not among it: the adapter
+ * decides membership itself, through the project walk. So a file the tsconfig
+ * includes, such as a new global declaration, changed no watch input a host
+ * had, and a watching host never re-ran the modules whose generated code it
+ * changes. This input carries that membership to the host: its path is the
+ * project root, and its evidence is the walk's digest, every directory the walk
+ * entered, and the policy it applied.
+ *
+ * Built once per recorded directory list, so every module of a generation hands
+ * the host the same object.
+ *
+ * @evidence contracts/common.md#principled-implementation The root path carries the adapter's actual membership digest, directory population and walk policy, expressing root-file selection rather than equating it with one compiler input hash.
+ * @evidence contracts/common.md#clear-and-simple-design One optional carrier represents a recorded project walk, with a memo keyed by generation and the recorded directory-list reference.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A generation without a recorded walk returns undefined rather than inventing a default membership result from its root name.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership ownership, absent walks and reference reuse, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Root identity comes from the generation's native context and directory spellings retain the walk's observed policy rather than relying on an OS-wide case model.
+ * @evidence contracts/performance.md#efficient-algorithms Missing directory state returns immediately and a matching list needs only keyed/reference access. Construction additionally resolves root identity through the generation context, scans all D records, sorts relevant directory pairs, serializes/hashes policy and selected text, then maps all D directory paths. Native cold observations, path/key text and digest temporary arrays/encoding costs remain included; no new project walk occurs.
+ * @evidence contracts/performance.md#reuse-equivalent-work The weak memo shares by generation and directory-array identity, requiring immutable policy/entries, fixed root and a valid generation native identity view. A replacement list rebuilds the carrier, and callers must not mutate shared evidence; array identity alone does not establish those premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The memo retains one current directory-list reference and membership carrier per generation, including D path references, policy reference, digest and native identity text. Replacement drops the owner's previous entry; borrowers can retain earlier carriers, policies or lists. Weak keys do not keep generations alive, but provide no byte cap on these payloads. No watcher or descriptor is acquired here.
+ */
+function projectMembershipInput(cached) {
+    const directories = cached.projectDirectories;
+    if (directories === undefined)
+        return undefined;
+    const memo = PROJECT_MEMBERSHIP_INPUTS.get(cached);
+    if (memo !== undefined && memo.directories === directories) {
+        return memo.input;
+    }
+    const input = {
+        evidence: {
+            identity: pathIdentityKey(cached.projectRoot, envelopeDerivation(cached).identityContext),
+            missing: false,
+            state: {
+                codec: "membership",
+                digest: projectMembershipDigest(cached.membershipPolicy, directories),
+                directories: directories.map((directory) => directory.path),
+                policy: cached.membershipPolicy,
+            },
+        },
+        file: cached.projectRoot,
+    };
+    PROJECT_MEMBERSHIP_INPUTS.set(cached, { directories, input });
+    return input;
+}
+
+export { projectMembershipInput };
+//# sourceMappingURL=projectMembershipInput.mjs.map

package/lib/core/transform/watch/projectMembershipInput.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectMembershipInput.mjs","sources":["../../../../src/core/transform/watch/projectMembershipInput.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;AACA,MAAM,yBAAyB,GAAG,IAAI,OAAO,EAG1C;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,sBAAsB,CACpC,MAAkC,EAAA;AAElC,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,kBAAkB;IAC7C,IAAI,WAAW,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IAC/C,MAAM,IAAI,GAAG,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC;IAClD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,KAAK,WAAW,EAAE;QAC1D,OAAO,IAAI,CAAC,KAAK;IACnB;AACA,IAAA,MAAM,KAAK,GAAmB;AAC5B,QAAA,QAAQ,EAAE;AACR,YAAA,QAAQ,EAAE,eAAe,CACvB,MAAM,CAAC,WAAW,EAClB,kBAAkB,CAAC,MAAM,CAAC,CAAC,eAAe,CAC3C;AACD,YAAA,OAAO,EAAE,KAAK;AACd,YAAA,KAAK,EAAE;AACL,gBAAA,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAE,uBAAuB,CAAC,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC;AACrE,gBAAA,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,IAAI,CAAC;gBAC3D,MAAM,EAAE,MAAM,CAAC,gBAAgB;AAChC,aAAA;AACF,SAAA;QACD,IAAI,EAAE,MAAM,CAAC,WAAW;KACzB;IACD,yBAAyB,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAC7D,IAAA,OAAO,KAAK;AACd;;;;"}

package/lib/core/transform/watch/selectionInputs.d.cts

@@ -0,0 +1,29 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscWatchInput } from "./TtscWatchInput.cjs";
+/**
+ * The watch inputs for the configs that routed a delivery's file to the
+ * selected project (samchon/ttsc#1397).
+ *
+ * The generation's own inputs cover the selected config and its `extends`
+ * chain, but not the solution config whose `references` led there. Editing that
+ * config, or the `include` of a project searched before the selected one, can
+ * move the file to another project, and so can a referenced config appearing,
+ * so reported config reads and failed discovery candidates are registered with
+ * the host as well, with current host state as evidence or an unavailable
+ * content marker when reading fails. They join the delivery's other inputs in
+ * the one batch the host receives, so a config both name is handed once.
+ *
+ * @param consulted Ordered reported config reads and failed discovery names.
+ * @param filesystem The filesystem the evidence is read through.
+ * @param spell The spelling every input is handed under for this delivery
+ *   (`hostSpelling`).
+ * @evidence contracts/common.md#principled-implementation Reported routing spellings receive current host byte/kind observations, including failed discovery names whose appearance can change selection. Unavailable reads use the supported marker without certifying physical absence; recorded native identity stays distinct from notification spelling.
+ * @evidence contracts/common.md#clear-and-simple-design A delivery-local identity context and one map produce the evidence batch; callers own deduplication and project-record accumulation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable configurations receive the supported missing state instead of fabricated contents or an assumption that the selected config is the only routing dependency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain solution and searched-project dependencies, missing appearance and spelling parameters, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and supplied filesystem observations preserve actual identity; the caller's spelling callback changes registration spelling without altering the recorded facts.
+ * @evidence contracts/performance.md#efficient-algorithms Every consulted occurrence is resolved, read/hashed or classified after read failure, queried for native identity and passed once to the caller spelling callback. Cost includes total bytes plus path/key text, cold ancestor/case/realpath observations and delegated callback work; duplicate occurrences still read current host state. The output retains one entry per occurrence, while the call-local identity context grows with queried paths/ancestors. This operation performs no project or subtree enumeration.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation observes current routing contents for one delivery; callers share the resulting batch across their callbacks rather than trusting earlier hashes without validity evidence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The batch and identity context are local and no cache, descriptor or task survives independently of the caller.
+ */
+export declare function selectionInputs(consulted: readonly string[], filesystem: TtscTransformFilesystemOperations, spell: (input: string) => string): TtscWatchInput[];

package/lib/core/transform/watch/selectionInputs.d.mts

@@ -0,0 +1,29 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscWatchInput } from "./TtscWatchInput.mjs";
+/**
+ * The watch inputs for the configs that routed a delivery's file to the
+ * selected project (samchon/ttsc#1397).
+ *
+ * The generation's own inputs cover the selected config and its `extends`
+ * chain, but not the solution config whose `references` led there. Editing that
+ * config, or the `include` of a project searched before the selected one, can
+ * move the file to another project, and so can a referenced config appearing,
+ * so reported config reads and failed discovery candidates are registered with
+ * the host as well, with current host state as evidence or an unavailable
+ * content marker when reading fails. They join the delivery's other inputs in
+ * the one batch the host receives, so a config both name is handed once.
+ *
+ * @param consulted Ordered reported config reads and failed discovery names.
+ * @param filesystem The filesystem the evidence is read through.
+ * @param spell The spelling every input is handed under for this delivery
+ *   (`hostSpelling`).
+ * @evidence contracts/common.md#principled-implementation Reported routing spellings receive current host byte/kind observations, including failed discovery names whose appearance can change selection. Unavailable reads use the supported marker without certifying physical absence; recorded native identity stays distinct from notification spelling.
+ * @evidence contracts/common.md#clear-and-simple-design A delivery-local identity context and one map produce the evidence batch; callers own deduplication and project-record accumulation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable configurations receive the supported missing state instead of fabricated contents or an assumption that the selected config is the only routing dependency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain solution and searched-project dependencies, missing appearance and spelling parameters, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and supplied filesystem observations preserve actual identity; the caller's spelling callback changes registration spelling without altering the recorded facts.
+ * @evidence contracts/performance.md#efficient-algorithms Every consulted occurrence is resolved, read/hashed or classified after read failure, queried for native identity and passed once to the caller spelling callback. Cost includes total bytes plus path/key text, cold ancestor/case/realpath observations and delegated callback work; duplicate occurrences still read current host state. The output retains one entry per occurrence, while the call-local identity context grows with queried paths/ancestors. This operation performs no project or subtree enumeration.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation observes current routing contents for one delivery; callers share the resulting batch across their callbacks rather than trusting earlier hashes without validity evidence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The batch and identity context are local and no cache, descriptor or task survives independently of the caller.
+ */
+export declare function selectionInputs(consulted: readonly string[], filesystem: TtscTransformFilesystemOperations, spell: (input: string) => string): TtscWatchInput[];

package/lib/core/transform/watch/selectionInputs.d.ts

@@ -0,0 +1,29 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscWatchInput } from "./TtscWatchInput";
+/**
+ * The watch inputs for the configs that routed a delivery's file to the
+ * selected project (samchon/ttsc#1397).
+ *
+ * The generation's own inputs cover the selected config and its `extends`
+ * chain, but not the solution config whose `references` led there. Editing that
+ * config, or the `include` of a project searched before the selected one, can
+ * move the file to another project, and so can a referenced config appearing,
+ * so reported config reads and failed discovery candidates are registered with
+ * the host as well, with current host state as evidence or an unavailable
+ * content marker when reading fails. They join the delivery's other inputs in
+ * the one batch the host receives, so a config both name is handed once.
+ *
+ * @param consulted Ordered reported config reads and failed discovery names.
+ * @param filesystem The filesystem the evidence is read through.
+ * @param spell The spelling every input is handed under for this delivery
+ *   (`hostSpelling`).
+ * @evidence contracts/common.md#principled-implementation Reported routing spellings receive current host byte/kind observations, including failed discovery names whose appearance can change selection. Unavailable reads use the supported marker without certifying physical absence; recorded native identity stays distinct from notification spelling.
+ * @evidence contracts/common.md#clear-and-simple-design A delivery-local identity context and one map produce the evidence batch; callers own deduplication and project-record accumulation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable configurations receive the supported missing state instead of fabricated contents or an assumption that the selected config is the only routing dependency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain solution and searched-project dependencies, missing appearance and spelling parameters, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and supplied filesystem observations preserve actual identity; the caller's spelling callback changes registration spelling without altering the recorded facts.
+ * @evidence contracts/performance.md#efficient-algorithms Every consulted occurrence is resolved, read/hashed or classified after read failure, queried for native identity and passed once to the caller spelling callback. Cost includes total bytes plus path/key text, cold ancestor/case/realpath observations and delegated callback work; duplicate occurrences still read current host state. The output retains one entry per occurrence, while the call-local identity context grows with queried paths/ancestors. This operation performs no project or subtree enumeration.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation observes current routing contents for one delivery; callers share the resulting batch across their callbacks rather than trusting earlier hashes without validity evidence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The batch and identity context are local and no cache, descriptor or task survives independently of the caller.
+ */
+export declare function selectionInputs(consulted: readonly string[], filesystem: TtscTransformFilesystemOperations, spell: (input: string) => string): TtscWatchInput[];

package/lib/core/transform/watch/selectionInputs.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var path = require('node:path');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+
+/**
+ * The watch inputs for the configs that routed a delivery's file to the
+ * selected project (samchon/ttsc#1397).
+ *
+ * The generation's own inputs cover the selected config and its `extends`
+ * chain, but not the solution config whose `references` led there. Editing that
+ * config, or the `include` of a project searched before the selected one, can
+ * move the file to another project, and so can a referenced config appearing,
+ * so reported config reads and failed discovery candidates are registered with
+ * the host as well, with current host state as evidence or an unavailable
+ * content marker when reading fails. They join the delivery's other inputs in
+ * the one batch the host receives, so a config both name is handed once.
+ *
+ * @param consulted Ordered reported config reads and failed discovery names.
+ * @param filesystem The filesystem the evidence is read through.
+ * @param spell The spelling every input is handed under for this delivery
+ *   (`hostSpelling`).
+ * @evidence contracts/common.md#principled-implementation Reported routing spellings receive current host byte/kind observations, including failed discovery names whose appearance can change selection. Unavailable reads use the supported marker without certifying physical absence; recorded native identity stays distinct from notification spelling.
+ * @evidence contracts/common.md#clear-and-simple-design A delivery-local identity context and one map produce the evidence batch; callers own deduplication and project-record accumulation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable configurations receive the supported missing state instead of fabricated contents or an assumption that the selected config is the only routing dependency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain solution and searched-project dependencies, missing appearance and spelling parameters, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and supplied filesystem observations preserve actual identity; the caller's spelling callback changes registration spelling without altering the recorded facts.
+ * @evidence contracts/performance.md#efficient-algorithms Every consulted occurrence is resolved, read/hashed or classified after read failure, queried for native identity and passed once to the caller spelling callback. Cost includes total bytes plus path/key text, cold ancestor/case/realpath observations and delegated callback work; duplicate occurrences still read current host state. The output retains one entry per occurrence, while the call-local identity context grows with queried paths/ancestors. This operation performs no project or subtree enumeration.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation observes current routing contents for one delivery; callers share the resulting batch across their callbacks rather than trusting earlier hashes without validity evidence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The batch and identity context are local and no cache, descriptor or task survives independently of the caller.
+ */
+function selectionInputs(consulted, filesystem, spell) {
+    if (consulted.length === 0)
+        return [];
+    const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem);
+    return consulted.map((config) => {
+        const file = path.resolve(config);
+        const hash = hostInputStateHash.hostInputStateHash(file, filesystem);
+        return {
+            evidence: {
+                identity: pathIdentityKey.pathIdentityKey(file, identities),
+                missing: hash === null,
+                state: { codec: "host", hash: hash ?? MISSING_INPUT_STATE.MISSING_INPUT_STATE },
+                ...(hash === null ? { unavailable: "missing" } : {}),
+            },
+            file: spell(file),
+        };
+    });
+}
+
+exports.selectionInputs = selectionInputs;
+//# sourceMappingURL=selectionInputs.js.map

package/lib/core/transform/watch/selectionInputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionInputs.js","sources":["../../../../src/core/transform/watch/selectionInputs.ts"],"sourcesContent":[null],"names":["createHostPathIdentityContext","hostInputStateHash","pathIdentityKey","MISSING_INPUT_STATE"],"mappings":";;;;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;SACa,eAAe,CAC7B,SAA4B,EAC5B,UAA6C,EAC7C,KAAgC,EAAA;AAEhC,IAAA,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;AAAE,QAAA,OAAO,EAAE;AACrC,IAAA,MAAM,UAAU,GAAGA,2DAA6B,CAAC,UAAU,CAAC;AAC5D,IAAA,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,KAAI;QAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,MAAM,IAAI,GAAGC,qCAAkB,CAAC,IAAI,EAAE,UAAU,CAAC;QACjD,OAAO;AACL,YAAA,QAAQ,EAAE;AACR,gBAAA,QAAQ,EAAEC,+BAAe,CAAC,IAAI,EAAE,UAAU,CAAC;gBAC3C,OAAO,EAAE,IAAI,KAAK,IAAI;gBACtB,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,IAAIC,uCAAmB,EAAE;AAC3D,gBAAA,IAAI,IAAI,KAAK,IAAI,GAAG,EAAE,WAAW,EAAE,SAAkB,EAAE,GAAG,EAAE,CAAC;AAC9D,aAAA;AACD,YAAA,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;SAClB;AACH,IAAA,CAAC,CAAC;AACJ;;;;"}

package/lib/core/transform/watch/selectionInputs.mjs

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+
+/**
+ * The watch inputs for the configs that routed a delivery's file to the
+ * selected project (samchon/ttsc#1397).
+ *
+ * The generation's own inputs cover the selected config and its `extends`
+ * chain, but not the solution config whose `references` led there. Editing that
+ * config, or the `include` of a project searched before the selected one, can
+ * move the file to another project, and so can a referenced config appearing,
+ * so reported config reads and failed discovery candidates are registered with
+ * the host as well, with current host state as evidence or an unavailable
+ * content marker when reading fails. They join the delivery's other inputs in
+ * the one batch the host receives, so a config both name is handed once.
+ *
+ * @param consulted Ordered reported config reads and failed discovery names.
+ * @param filesystem The filesystem the evidence is read through.
+ * @param spell The spelling every input is handed under for this delivery
+ *   (`hostSpelling`).
+ * @evidence contracts/common.md#principled-implementation Reported routing spellings receive current host byte/kind observations, including failed discovery names whose appearance can change selection. Unavailable reads use the supported marker without certifying physical absence; recorded native identity stays distinct from notification spelling.
+ * @evidence contracts/common.md#clear-and-simple-design A delivery-local identity context and one map produce the evidence batch; callers own deduplication and project-record accumulation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable configurations receive the supported missing state instead of fabricated contents or an assumption that the selected config is the only routing dependency.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain solution and searched-project dependencies, missing appearance and spelling parameters, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and supplied filesystem observations preserve actual identity; the caller's spelling callback changes registration spelling without altering the recorded facts.
+ * @evidence contracts/performance.md#efficient-algorithms Every consulted occurrence is resolved, read/hashed or classified after read failure, queried for native identity and passed once to the caller spelling callback. Cost includes total bytes plus path/key text, cold ancestor/case/realpath observations and delegated callback work; duplicate occurrences still read current host state. The output retains one entry per occurrence, while the call-local identity context grows with queried paths/ancestors. This operation performs no project or subtree enumeration.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation observes current routing contents for one delivery; callers share the resulting batch across their callbacks rather than trusting earlier hashes without validity evidence.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The batch and identity context are local and no cache, descriptor or task survives independently of the caller.
+ */
+function selectionInputs(consulted, filesystem, spell) {
+    if (consulted.length === 0)
+        return [];
+    const identities = createHostPathIdentityContext(filesystem);
+    return consulted.map((config) => {
+        const file = path.resolve(config);
+        const hash = hostInputStateHash(file, filesystem);
+        return {
+            evidence: {
+                identity: pathIdentityKey(file, identities),
+                missing: hash === null,
+                state: { codec: "host", hash: hash ?? MISSING_INPUT_STATE },
+                ...(hash === null ? { unavailable: "missing" } : {}),
+            },
+            file: spell(file),
+        };
+    });
+}
+
+export { selectionInputs };
+//# sourceMappingURL=selectionInputs.mjs.map

package/lib/core/transform/watch/selectionInputs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionInputs.mjs","sources":["../../../../src/core/transform/watch/selectionInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;SACa,eAAe,CAC7B,SAA4B,EAC5B,UAA6C,EAC7C,KAAgC,EAAA;AAEhC,IAAA,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;AAAE,QAAA,OAAO,EAAE;AACrC,IAAA,MAAM,UAAU,GAAG,6BAA6B,CAAC,UAAU,CAAC;AAC5D,IAAA,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,KAAI;QAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC;QACjD,OAAO;AACL,YAAA,QAAQ,EAAE;AACR,gBAAA,QAAQ,EAAE,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC;gBAC3C,OAAO,EAAE,IAAI,KAAK,IAAI;gBACtB,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,IAAI,mBAAmB,EAAE;AAC3D,gBAAA,IAAI,IAAI,KAAK,IAAI,GAAG,EAAE,WAAW,EAAE,SAAkB,EAAE,GAAG,EAAE,CAAC;AAC9D,aAAA;AACD,YAAA,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;SAClB;AACH,IAAA,CAAC,CAAC;AACJ;;;;"}

package/lib/core/transform/watch/watchInputEvidenceMatchesBaseline.d.cts

@@ -0,0 +1,20 @@
+import type { TtscWatchInputEvidence } from "./TtscWatchInputEvidence.cjs";
+import type { TtscWatchInputKeyBaseline } from "./TtscWatchInputKeyBaseline.cjs";
+/**
+ * Compare generation evidence with the main process's exact key baseline.
+ *
+ * A codec matches only the facts the baseline actually captured. Native,
+ * listing and plugin-tree observations require their optional payloads;
+ * membership is a
+ * separate project walk and cannot match one path's baseline.
+ *
+ * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
+ * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown state and unsupported membership fail comparison, while older baselines without a listing cannot silently validate a newly recorded listing predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain optional observation coverage and membership limits, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Realpaths compare through actual native identity capabilities; listing names remain observed compiler values rather than case-folded OS assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Structural baseline validation processes supplied keys/text and encoded listing names before the selected codec comparison. Ordered name equality visits at most E names and their compared text; physical-target predicates also pay native identity/path costs. Validation uses local key arrays, serialized key text and adjacent name buffers; comparison retains no copied listing or verdict.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The baseline is already captured by its key owner; this comparison stores no reusable verdict independent of that baseline's temporal validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The comparison retains no cache or native handle; its identity context and ordered entry comparison are call-local.
+ */
+export declare function watchInputEvidenceMatchesBaseline(evidence: TtscWatchInputEvidence, baseline: TtscWatchInputKeyBaseline): boolean;

package/lib/core/transform/watch/watchInputEvidenceMatchesBaseline.d.mts

@@ -0,0 +1,20 @@
+import type { TtscWatchInputEvidence } from "./TtscWatchInputEvidence.mjs";
+import type { TtscWatchInputKeyBaseline } from "./TtscWatchInputKeyBaseline.mjs";
+/**
+ * Compare generation evidence with the main process's exact key baseline.
+ *
+ * A codec matches only the facts the baseline actually captured. Native,
+ * listing and plugin-tree observations require their optional payloads;
+ * membership is a
+ * separate project walk and cannot match one path's baseline.
+ *
+ * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
+ * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown state and unsupported membership fail comparison, while older baselines without a listing cannot silently validate a newly recorded listing predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain optional observation coverage and membership limits, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Realpaths compare through actual native identity capabilities; listing names remain observed compiler values rather than case-folded OS assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Structural baseline validation processes supplied keys/text and encoded listing names before the selected codec comparison. Ordered name equality visits at most E names and their compared text; physical-target predicates also pay native identity/path costs. Validation uses local key arrays, serialized key text and adjacent name buffers; comparison retains no copied listing or verdict.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The baseline is already captured by its key owner; this comparison stores no reusable verdict independent of that baseline's temporal validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The comparison retains no cache or native handle; its identity context and ordered entry comparison are call-local.
+ */
+export declare function watchInputEvidenceMatchesBaseline(evidence: TtscWatchInputEvidence, baseline: TtscWatchInputKeyBaseline): boolean;

package/lib/core/transform/watch/watchInputEvidenceMatchesBaseline.d.ts

@@ -0,0 +1,20 @@
+import type { TtscWatchInputEvidence } from "./TtscWatchInputEvidence";
+import type { TtscWatchInputKeyBaseline } from "./TtscWatchInputKeyBaseline";
+/**
+ * Compare generation evidence with the main process's exact key baseline.
+ *
+ * A codec matches only the facts the baseline actually captured. Native,
+ * listing and plugin-tree observations require their optional payloads;
+ * membership is a
+ * separate project walk and cannot match one path's baseline.
+ *
+ * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
+ * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown state and unsupported membership fail comparison, while older baselines without a listing cannot silently validate a newly recorded listing predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain optional observation coverage and membership limits, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Realpaths compare through actual native identity capabilities; listing names remain observed compiler values rather than case-folded OS assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Structural baseline validation processes supplied keys/text and encoded listing names before the selected codec comparison. Ordered name equality visits at most E names and their compared text; physical-target predicates also pay native identity/path costs. Validation uses local key arrays, serialized key text and adjacent name buffers; comparison retains no copied listing or verdict.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The baseline is already captured by its key owner; this comparison stores no reusable verdict independent of that baseline's temporal validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The comparison retains no cache or native handle; its identity context and ordered entry comparison are call-local.
+ */
+export declare function watchInputEvidenceMatchesBaseline(evidence: TtscWatchInputEvidence, baseline: TtscWatchInputKeyBaseline): boolean;

package/lib/core/transform/watch/watchInputEvidenceMatchesBaseline.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var sameHostInputRealpath = require('../inputs/sameHostInputRealpath.js');
+var isWatchInputKeyBaseline = require('./isWatchInputKeyBaseline.js');
+
+/**
+ * Compare generation evidence with the main process's exact key baseline.
+ *
+ * A codec matches only the facts the baseline actually captured. Native,
+ * listing and plugin-tree observations require their optional payloads;
+ * membership is a
+ * separate project walk and cannot match one path's baseline.
+ *
+ * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
+ * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown state and unsupported membership fail comparison, while older baselines without a listing cannot silently validate a newly recorded listing predicate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain optional observation coverage and membership limits, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Realpaths compare through actual native identity capabilities; listing names remain observed compiler values rather than case-folded OS assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Structural baseline validation processes supplied keys/text and encoded listing names before the selected codec comparison. Ordered name equality visits at most E names and their compared text; physical-target predicates also pay native identity/path costs. Validation uses local key arrays, serialized key text and adjacent name buffers; comparison retains no copied listing or verdict.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The baseline is already captured by its key owner; this comparison stores no reusable verdict independent of that baseline's temporal validity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The comparison retains no cache or native handle; its identity context and ordered entry comparison are call-local.
+ */
+function watchInputEvidenceMatchesBaseline(evidence, baseline) {
+    if (!isWatchInputKeyBaseline.isWatchInputKeyBaseline(baseline) ||
+        evidence.identity !== baseline.identity ||
+        evidence.state === undefined) {
+        return false;
+    }
+    const broad = broadWatchInputBaseline(baseline);
+    if (evidence.state.codec === "host") {
+        return broad !== undefined && evidence.state.hash === broad.hostHash;
+    }
+    const identities = createHostPathIdentityContext.createHostPathIdentityContext();
+    if (evidence.state.codec === "graph") {
+        return (broad !== undefined &&
+            evidence.state.hash === broad.graphHash &&
+            sameHostInputRealpath.sameHostInputRealpath(evidence.state.realpath, broad.realpath.ok ? broad.realpath.path : null, identities));
+    }
+    // A key baseline records one path's own state, and the project's root-file
+    // membership is a walk over many; it never stands for one.
+    if (evidence.state.codec === "membership")
+        return false;
+    // A plugin source directory's state is a walk over many files too, and a
+    // key baseline carries it only where it was captured as one.
+    if (evidence.state.codec === "tree") {
+        return broad !== undefined && broad.tree === evidence.state.digest;
+    }
+    const observation = evidence.state.observation;
+    for (const predicate of observation.nativePredicates ?? []) {
+        const current = broad?.nativePredicates?.[predicate.kind];
+        if (predicate.version !== 1 ||
+            !predicate.identityStable ||
+            current === undefined ||
+            predicate.digest !== current.digest ||
+            !sameHostInputRealpath.sameHostInputRealpath(predicate.realpath, current.realpath, identities)) {
+            return false;
+        }
+    }
+    if (observation.accessibleEntries !== undefined &&
+        (broad?.accessibleEntries === undefined ||
+            !sameEntryNames(observation.accessibleEntries.directories, broad.accessibleEntries.directories) ||
+            !sameEntryNames(observation.accessibleEntries.files, broad.accessibleEntries.files))) {
+        return false;
+    }
+    if (observation.fileExists !== undefined &&
+        observation.fileExists !== baseline.fileExists) {
+        return false;
+    }
+    if (observation.directoryExists !== undefined &&
+        (broad === undefined ||
+            observation.directoryExists !== broad.directoryExists)) {
+        return false;
+    }
+    if (observation.stat !== undefined &&
+        (broad === undefined || observation.stat !== broad.stat)) {
+        return false;
+    }
+    if (observation.readFile !== undefined &&
+        (broad === undefined ||
+            (observation.readFile.ok &&
+                observation.readFile.hash !== broad.graphReadHash) ||
+            (!observation.readFile.ok && broad.graphReadHash !== null))) {
+        return false;
+    }
+    if (observation.realpath !== undefined) {
+        if (broad === undefined) {
+            return false;
+        }
+        if (observation.realpath.ok !== broad.realpath.ok) {
+            return false;
+        }
+        if (observation.realpath.ok &&
+            broad.realpath.ok &&
+            !sameHostInputRealpath.sameHostInputRealpath(observation.realpath.path, broad.realpath.path, identities)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Return a broad baseline after the complete entry has been validated. */
+function broadWatchInputBaseline(baseline) {
+    return "directoryExists" in baseline ? baseline : undefined;
+}
+/** Compare ordered entry values without allocating serialized copies. */
+function sameEntryNames(left, right) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; ++index) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
+}
+
+exports.watchInputEvidenceMatchesBaseline = watchInputEvidenceMatchesBaseline;
+//# sourceMappingURL=watchInputEvidenceMatchesBaseline.js.map

package/lib/core/transform/watch/watchInputEvidenceMatchesBaseline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchInputEvidenceMatchesBaseline.js","sources":["../../../../src/core/transform/watch/watchInputEvidenceMatchesBaseline.ts"],"sourcesContent":[null],"names":["isWatchInputKeyBaseline","createHostPathIdentityContext","sameHostInputRealpath"],"mappings":"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"}