@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,18 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.cjs";
+import type { TtscWatchInputFileBaseline } from "./TtscWatchInputFileBaseline.cjs";
+/**
+ * Capture two equal file-predicate observations for implicit project discovery.
+ * A failed stat records a negative file predicate. A mismatch or escaping
+ * identity observation failure declines capture; equal samples do not establish
+ * an atomic filesystem snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation Fresh identity and regular-file predicates are captured twice and compared structurally, preserving discovery's stat.isFile semantics rather than compiler byte-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design A narrow local capture avoids broad graph and content facts that project discovery does not consume.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A failed stat remains a negative file predicate and an unstable identity declines capture; candidate names cannot manufacture successful availability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies discovery, rejection and the sampling limitation, with a blank tag separator following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Supplied stat and identity operations determine native availability and case-sensitive identity, not an operating-system-wide casing rule.
+ * @evidence contracts/performance.md#efficient-algorithms Two narrow observations read metadata and native identity only, with path/component work and any case-policy directory observation owned by identity resolution; no file bytes or subtree content are scanned for this discovery predicate.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each capture asks for independent current observations; the cache-key caller owns permission to reuse the resulting baseline.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity contexts and baseline objects remain call-local and no descriptor or task is acquired.
+ */
+export declare function captureWatchInputFileBaseline(file: string, filesystem?: TtscTransformFilesystemOperations): TtscWatchInputFileBaseline | undefined;

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

@@ -0,0 +1,18 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations.mjs";
+import type { TtscWatchInputFileBaseline } from "./TtscWatchInputFileBaseline.mjs";
+/**
+ * Capture two equal file-predicate observations for implicit project discovery.
+ * A failed stat records a negative file predicate. A mismatch or escaping
+ * identity observation failure declines capture; equal samples do not establish
+ * an atomic filesystem snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation Fresh identity and regular-file predicates are captured twice and compared structurally, preserving discovery's stat.isFile semantics rather than compiler byte-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design A narrow local capture avoids broad graph and content facts that project discovery does not consume.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A failed stat remains a negative file predicate and an unstable identity declines capture; candidate names cannot manufacture successful availability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies discovery, rejection and the sampling limitation, with a blank tag separator following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Supplied stat and identity operations determine native availability and case-sensitive identity, not an operating-system-wide casing rule.
+ * @evidence contracts/performance.md#efficient-algorithms Two narrow observations read metadata and native identity only, with path/component work and any case-policy directory observation owned by identity resolution; no file bytes or subtree content are scanned for this discovery predicate.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each capture asks for independent current observations; the cache-key caller owns permission to reuse the resulting baseline.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity contexts and baseline objects remain call-local and no descriptor or task is acquired.
+ */
+export declare function captureWatchInputFileBaseline(file: string, filesystem?: TtscTransformFilesystemOperations): TtscWatchInputFileBaseline | undefined;

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

@@ -0,0 +1,18 @@
+import type { TtscTransformFilesystemOperations } from "../filesystem/TtscTransformFilesystemOperations";
+import type { TtscWatchInputFileBaseline } from "./TtscWatchInputFileBaseline";
+/**
+ * Capture two equal file-predicate observations for implicit project discovery.
+ * A failed stat records a negative file predicate. A mismatch or escaping
+ * identity observation failure declines capture; equal samples do not establish
+ * an atomic filesystem snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation Fresh identity and regular-file predicates are captured twice and compared structurally, preserving discovery's stat.isFile semantics rather than compiler byte-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design A narrow local capture avoids broad graph and content facts that project discovery does not consume.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A failed stat remains a negative file predicate and an unstable identity declines capture; candidate names cannot manufacture successful availability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies discovery, rejection and the sampling limitation, with a blank tag separator following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Supplied stat and identity operations determine native availability and case-sensitive identity, not an operating-system-wide casing rule.
+ * @evidence contracts/performance.md#efficient-algorithms Two narrow observations read metadata and native identity only, with path/component work and any case-policy directory observation owned by identity resolution; no file bytes or subtree content are scanned for this discovery predicate.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each capture asks for independent current observations; the cache-key caller owns permission to reuse the resulting baseline.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity contexts and baseline objects remain call-local and no descriptor or task is acquired.
+ */
+export declare function captureWatchInputFileBaseline(file: string, filesystem?: TtscTransformFilesystemOperations): TtscWatchInputFileBaseline | undefined;

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

@@ -0,0 +1,51 @@
+'use strict';
+
+var DEFAULT_FILESYSTEM_OPERATIONS = require('../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var stableStringify = require('../utils/stableStringify.js');
+
+/**
+ * Capture two equal file-predicate observations for implicit project discovery.
+ * A failed stat records a negative file predicate. A mismatch or escaping
+ * identity observation failure declines capture; equal samples do not establish
+ * an atomic filesystem snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation Fresh identity and regular-file predicates are captured twice and compared structurally, preserving discovery's stat.isFile semantics rather than compiler byte-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design A narrow local capture avoids broad graph and content facts that project discovery does not consume.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A failed stat remains a negative file predicate and an unstable identity declines capture; candidate names cannot manufacture successful availability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies discovery, rejection and the sampling limitation, with a blank tag separator following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Supplied stat and identity operations determine native availability and case-sensitive identity, not an operating-system-wide casing rule.
+ * @evidence contracts/performance.md#efficient-algorithms Two narrow observations read metadata and native identity only, with path/component work and any case-policy directory observation owned by identity resolution; no file bytes or subtree content are scanned for this discovery predicate.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each capture asks for independent current observations; the cache-key caller owns permission to reuse the resulting baseline.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity contexts and baseline objects remain call-local and no descriptor or task is acquired.
+ */
+function captureWatchInputFileBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS.DEFAULT_FILESYSTEM_OPERATIONS) {
+    const capture = () => {
+        const identities = createHostPathIdentityContext.createHostPathIdentityContext(filesystem);
+        let fileExists = false;
+        try {
+            fileExists = filesystem.stat(file).isFile();
+        }
+        catch {
+            // Project discovery rejects every candidate not proven to be a file.
+        }
+        return {
+            fileExists,
+            identity: pathIdentityKey.pathIdentityKey(file, identities),
+        };
+    };
+    try {
+        const before = capture();
+        const after = capture();
+        return stableStringify.stableStringify(before) === stableStringify.stableStringify(after)
+            ? after
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+exports.captureWatchInputFileBaseline = captureWatchInputFileBaseline;
+//# sourceMappingURL=captureWatchInputFileBaseline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"captureWatchInputFileBaseline.js","sources":["../../../../src/core/transform/watch/captureWatchInputFileBaseline.ts"],"sourcesContent":[null],"names":["DEFAULT_FILESYSTEM_OPERATIONS","createHostPathIdentityContext","pathIdentityKey","stableStringify"],"mappings":";;;;;;;AAOA;;;;;;;;;;;;;;AAcG;SACa,6BAA6B,CAC3C,IAAY,EACZ,aAAgDA,2DAA6B,EAAA;IAE7E,MAAM,OAAO,GAAG,MAAiC;AAC/C,QAAA,MAAM,UAAU,GAAGC,2DAA6B,CAAC,UAAU,CAAC;QAC5D,IAAI,UAAU,GAAG,KAAK;AACtB,QAAA,IAAI;YACF,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE;QAC7C;AAAE,QAAA,MAAM;;QAER;QACA,OAAO;YACL,UAAU;AACV,YAAA,QAAQ,EAAEC,+BAAe,CAAC,IAAI,EAAE,UAAU,CAAC;SAC5C;AACH,IAAA,CAAC;AACD,IAAA,IAAI;AACF,QAAA,MAAM,MAAM,GAAG,OAAO,EAAE;AACxB,QAAA,MAAM,KAAK,GAAG,OAAO,EAAE;QACvB,OAAOC,+BAAe,CAAC,MAAM,CAAC,KAAKA,+BAAe,CAAC,KAAK;AACtD,cAAE;cACA,SAAS;IACf;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

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

@@ -0,0 +1,49 @@
+import { DEFAULT_FILESYSTEM_OPERATIONS } from '../filesystem/DEFAULT_FILESYSTEM_OPERATIONS.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { stableStringify } from '../utils/stableStringify.mjs';
+
+/**
+ * Capture two equal file-predicate observations for implicit project discovery.
+ * A failed stat records a negative file predicate. A mismatch or escaping
+ * identity observation failure declines capture; equal samples do not establish
+ * an atomic filesystem snapshot.
+ *
+ * @evidence contracts/common.md#principled-implementation Fresh identity and regular-file predicates are captured twice and compared structurally, preserving discovery's stat.isFile semantics rather than compiler byte-read semantics.
+ * @evidence contracts/common.md#clear-and-simple-design A narrow local capture avoids broad graph and content facts that project discovery does not consume.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A failed stat remains a negative file predicate and an unstable identity declines capture; candidate names cannot manufacture successful availability.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies discovery, rejection and the sampling limitation, with a blank tag separator following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Supplied stat and identity operations determine native availability and case-sensitive identity, not an operating-system-wide casing rule.
+ * @evidence contracts/performance.md#efficient-algorithms Two narrow observations read metadata and native identity only, with path/component work and any case-policy directory observation owned by identity resolution; no file bytes or subtree content are scanned for this discovery predicate.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each capture asks for independent current observations; the cache-key caller owns permission to reuse the resulting baseline.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Identity contexts and baseline objects remain call-local and no descriptor or task is acquired.
+ */
+function captureWatchInputFileBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const capture = () => {
+        const identities = createHostPathIdentityContext(filesystem);
+        let fileExists = false;
+        try {
+            fileExists = filesystem.stat(file).isFile();
+        }
+        catch {
+            // Project discovery rejects every candidate not proven to be a file.
+        }
+        return {
+            fileExists,
+            identity: pathIdentityKey(file, identities),
+        };
+    };
+    try {
+        const before = capture();
+        const after = capture();
+        return stableStringify(before) === stableStringify(after)
+            ? after
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+export { captureWatchInputFileBaseline };
+//# sourceMappingURL=captureWatchInputFileBaseline.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"captureWatchInputFileBaseline.mjs","sources":["../../../../src/core/transform/watch/captureWatchInputFileBaseline.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAOA;;;;;;;;;;;;;;AAcG;SACa,6BAA6B,CAC3C,IAAY,EACZ,aAAgD,6BAA6B,EAAA;IAE7E,MAAM,OAAO,GAAG,MAAiC;AAC/C,QAAA,MAAM,UAAU,GAAG,6BAA6B,CAAC,UAAU,CAAC;QAC5D,IAAI,UAAU,GAAG,KAAK;AACtB,QAAA,IAAI;YACF,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE;QAC7C;AAAE,QAAA,MAAM;;QAER;QACA,OAAO;YACL,UAAU;AACV,YAAA,QAAQ,EAAE,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC;SAC5C;AACH,IAAA,CAAC;AACD,IAAA,IAAI;AACF,QAAA,MAAM,MAAM,GAAG,OAAO,EAAE;AACxB,QAAA,MAAM,KAAK,GAAG,OAAO,EAAE;QACvB,OAAO,eAAe,CAAC,MAAM,CAAC,KAAK,eAAe,CAAC,KAAK;AACtD,cAAE;cACA,SAAS;IACf;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

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

@@ -0,0 +1,30 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation.cjs";
+import type { TtscWatchInput } from "./TtscWatchInput.cjs";
+/**
+ * One input as a watch input, carrying identity from the generation's qualified
+ * native context and the state it recorded for the path: the compiler's
+ * predicate observation where it made one, the graph's hash and realpath for a
+ * realized input, the host bytes' hash for a walk or dependency-only input, or
+ * the state of a plugin source directory.
+ *
+ * State payloads are retained generation observations; identity queries share
+ * the generation context but a first spelling can still require native reads. A
+ * plugin source state takes precedence over other recorded codecs. An input
+ * with no recorded state returns `state` absent, leaving its caller to decide
+ * whether another observation is appropriate. No current byte read here
+ * manufactures evaluation-time state.
+ *
+ * @param spell The registration spelling callback. Predicate lookup uses the
+ *   native absolute lexical input; hash dictionaries use physical identity or
+ *   project keys without discarding the predicate's original spelling.
+ * @evidence contracts/common.md#principled-implementation Recorded plugin tree state takes precedence, then exact lexical predicates, external graph/host state and project host bytes. Own-entry hash guards preserve absent baselines; unknown state stays absent, with physical target/availability separate from registration spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One derivation maps retained generation facts into the documented watch carrier while the caller supplies its spelling policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown codec state stays absent; the missing marker is a supported observation value rather than a guessed content hash.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes generation evidence and spelling ownership, followed by separated acknowledgment tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve and the generation's identity context preserve actual filesystem identity separately from caller-selected lexical spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Each call allocates one carrier and performs lexical/identity queries plus a plugin-source lookup; a first plugin lookup may parse the full declared source record. Non-tree inputs also compute the project key before selecting the recorded codec. Cost includes key/path text, any cold native path/ancestor/case observations and one caller spelling callback, while recorded byte hashes are not reread. Shared context/plugin populations remain owner costs beyond this fixed carrier allocation.
+ * @evidence contracts/performance.md#reuse-equivalent-work Recorded hashes/predicates and plugin state come from one immutable generation. Identity and project-key queries share its context under a still-valid native view and fixed root; this operation creates a fresh carrier rather than memoizing it, and cannot certify those premises independently.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mapping stores no new persistent cache or handle; retained generation facts belong to the generation owner.
+ */
+export declare function evidencedWatchInput(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string, spell: (input: string) => string): TtscWatchInput;

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

@@ -0,0 +1,30 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation.mjs";
+import type { TtscWatchInput } from "./TtscWatchInput.mjs";
+/**
+ * One input as a watch input, carrying identity from the generation's qualified
+ * native context and the state it recorded for the path: the compiler's
+ * predicate observation where it made one, the graph's hash and realpath for a
+ * realized input, the host bytes' hash for a walk or dependency-only input, or
+ * the state of a plugin source directory.
+ *
+ * State payloads are retained generation observations; identity queries share
+ * the generation context but a first spelling can still require native reads. A
+ * plugin source state takes precedence over other recorded codecs. An input
+ * with no recorded state returns `state` absent, leaving its caller to decide
+ * whether another observation is appropriate. No current byte read here
+ * manufactures evaluation-time state.
+ *
+ * @param spell The registration spelling callback. Predicate lookup uses the
+ *   native absolute lexical input; hash dictionaries use physical identity or
+ *   project keys without discarding the predicate's original spelling.
+ * @evidence contracts/common.md#principled-implementation Recorded plugin tree state takes precedence, then exact lexical predicates, external graph/host state and project host bytes. Own-entry hash guards preserve absent baselines; unknown state stays absent, with physical target/availability separate from registration spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One derivation maps retained generation facts into the documented watch carrier while the caller supplies its spelling policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown codec state stays absent; the missing marker is a supported observation value rather than a guessed content hash.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes generation evidence and spelling ownership, followed by separated acknowledgment tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve and the generation's identity context preserve actual filesystem identity separately from caller-selected lexical spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Each call allocates one carrier and performs lexical/identity queries plus a plugin-source lookup; a first plugin lookup may parse the full declared source record. Non-tree inputs also compute the project key before selecting the recorded codec. Cost includes key/path text, any cold native path/ancestor/case observations and one caller spelling callback, while recorded byte hashes are not reread. Shared context/plugin populations remain owner costs beyond this fixed carrier allocation.
+ * @evidence contracts/performance.md#reuse-equivalent-work Recorded hashes/predicates and plugin state come from one immutable generation. Identity and project-key queries share its context under a still-valid native view and fixed root; this operation creates a fresh carrier rather than memoizing it, and cannot certify those premises independently.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mapping stores no new persistent cache or handle; retained generation facts belong to the generation owner.
+ */
+export declare function evidencedWatchInput(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string, spell: (input: string) => string): TtscWatchInput;

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

@@ -0,0 +1,30 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscEnvelopeDerivation } from "../envelope/TtscEnvelopeDerivation";
+import type { TtscWatchInput } from "./TtscWatchInput";
+/**
+ * One input as a watch input, carrying identity from the generation's qualified
+ * native context and the state it recorded for the path: the compiler's
+ * predicate observation where it made one, the graph's hash and realpath for a
+ * realized input, the host bytes' hash for a walk or dependency-only input, or
+ * the state of a plugin source directory.
+ *
+ * State payloads are retained generation observations; identity queries share
+ * the generation context but a first spelling can still require native reads. A
+ * plugin source state takes precedence over other recorded codecs. An input
+ * with no recorded state returns `state` absent, leaving its caller to decide
+ * whether another observation is appropriate. No current byte read here
+ * manufactures evaluation-time state.
+ *
+ * @param spell The registration spelling callback. Predicate lookup uses the
+ *   native absolute lexical input; hash dictionaries use physical identity or
+ *   project keys without discarding the predicate's original spelling.
+ * @evidence contracts/common.md#principled-implementation Recorded plugin tree state takes precedence, then exact lexical predicates, external graph/host state and project host bytes. Own-entry hash guards preserve absent baselines; unknown state stays absent, with physical target/availability separate from registration spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One derivation maps retained generation facts into the documented watch carrier while the caller supplies its spelling policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown codec state stays absent; the missing marker is a supported observation value rather than a guessed content hash.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes generation evidence and spelling ownership, followed by separated acknowledgment tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve and the generation's identity context preserve actual filesystem identity separately from caller-selected lexical spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Each call allocates one carrier and performs lexical/identity queries plus a plugin-source lookup; a first plugin lookup may parse the full declared source record. Non-tree inputs also compute the project key before selecting the recorded codec. Cost includes key/path text, any cold native path/ancestor/case observations and one caller spelling callback, while recorded byte hashes are not reread. Shared context/plugin populations remain owner costs beyond this fixed carrier allocation.
+ * @evidence contracts/performance.md#reuse-equivalent-work Recorded hashes/predicates and plugin state come from one immutable generation. Identity and project-key queries share its context under a still-valid native view and fixed root; this operation creates a fresh carrier rather than memoizing it, and cannot certify those premises independently.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mapping stores no new persistent cache or handle; retained generation facts belong to the generation owner.
+ */
+export declare function evidencedWatchInput(cached: TtscCachedProjectTransform, state: TtscEnvelopeDerivation, input: string, spell: (input: string) => string): TtscWatchInput;

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

@@ -0,0 +1,94 @@
+'use strict';
+
+var path = require('node:path');
+var derivationIdentity = require('../envelope/derivationIdentity.js');
+var selectPluginSourceInputs = require('../envelope/selectPluginSourceInputs.js');
+var toProjectKey = require('../project/toProjectKey.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+
+/**
+ * One input as a watch input, carrying identity from the generation's qualified
+ * native context and the state it recorded for the path: the compiler's
+ * predicate observation where it made one, the graph's hash and realpath for a
+ * realized input, the host bytes' hash for a walk or dependency-only input, or
+ * the state of a plugin source directory.
+ *
+ * State payloads are retained generation observations; identity queries share
+ * the generation context but a first spelling can still require native reads. A
+ * plugin source state takes precedence over other recorded codecs. An input
+ * with no recorded state returns `state` absent, leaving its caller to decide
+ * whether another observation is appropriate. No current byte read here
+ * manufactures evaluation-time state.
+ *
+ * @param spell The registration spelling callback. Predicate lookup uses the
+ *   native absolute lexical input; hash dictionaries use physical identity or
+ *   project keys without discarding the predicate's original spelling.
+ * @evidence contracts/common.md#principled-implementation Recorded plugin tree state takes precedence, then exact lexical predicates, external graph/host state and project host bytes. Own-entry hash guards preserve absent baselines; unknown state stays absent, with physical target/availability separate from registration spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One derivation maps retained generation facts into the documented watch carrier while the caller supplies its spelling policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown codec state stays absent; the missing marker is a supported observation value rather than a guessed content hash.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes generation evidence and spelling ownership, followed by separated acknowledgment tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve and the generation's identity context preserve actual filesystem identity separately from caller-selected lexical spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Each call allocates one carrier and performs lexical/identity queries plus a plugin-source lookup; a first plugin lookup may parse the full declared source record. Non-tree inputs also compute the project key before selecting the recorded codec. Cost includes key/path text, any cold native path/ancestor/case observations and one caller spelling callback, while recorded byte hashes are not reread. Shared context/plugin populations remain owner costs beyond this fixed carrier allocation.
+ * @evidence contracts/performance.md#reuse-equivalent-work Recorded hashes/predicates and plugin state come from one immutable generation. Identity and project-key queries share its context under a still-valid native view and fixed root; this operation creates a fresh carrier rather than memoizing it, and cannot certify those premises independently.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mapping stores no new persistent cache or handle; retained generation facts belong to the generation owner.
+ */
+function evidencedWatchInput(cached, state, input, spell) {
+    const external = cached.externalInputHashes ?? {};
+    const identity = derivationIdentity.derivationIdentity(state, input);
+    const spelling = path.resolve(input);
+    // A plugin's source directory is proven by the state its binary was built
+    // from, whatever else observed the path (samchon/ttsc#1487).
+    const digest = selectPluginSourceInputs.selectPluginSourceInputs(cached.result).get(spelling);
+    if (digest !== undefined) {
+        return {
+            file: spell(input),
+            evidence: {
+                identity,
+                missing: false,
+                state: { codec: "tree", digest },
+            },
+        };
+    }
+    const observation = cached.externalInputObservations?.[spelling];
+    const missing = observation?.fileExists === false ||
+        state.graph?.inputProofs.get(spelling)?.hash === null ||
+        external[identity] === MISSING_INPUT_STATE.MISSING_INPUT_STATE;
+    const projectKey = toProjectKey.toProjectKey(cached.projectRoot, input, state.identityContext);
+    const externalHash = Object.prototype.hasOwnProperty.call(external, identity)
+        ? external[identity]
+        : undefined;
+    const projectHash = Object.prototype.hasOwnProperty.call(cached.inputHashes, projectKey)
+        ? cached.inputHashes[projectKey]
+        : undefined;
+    const graphRealpaths = cached.externalInputRealpaths ?? {};
+    const stateEvidence = observation !== undefined
+        ? { codec: "predicates", observation }
+        : externalHash !== undefined &&
+            Object.prototype.hasOwnProperty.call(graphRealpaths, identity)
+            ? {
+                codec: "graph",
+                hash: externalHash,
+                realpath: graphRealpaths[identity] ?? null,
+            }
+            : externalHash !== undefined
+                ? { codec: "host", hash: externalHash }
+                : projectHash !== undefined
+                    ? { codec: "host", hash: projectHash }
+                    : undefined;
+    return {
+        file: spell(input),
+        evidence: {
+            identity,
+            missing,
+            ...(stateEvidence === undefined ? {} : { state: stateEvidence }),
+            unavailable: observation?.fileExists === false
+                ? "not-file"
+                : missing
+                    ? "missing"
+                    : undefined,
+        },
+    };
+}
+
+exports.evidencedWatchInput = evidencedWatchInput;
+//# sourceMappingURL=evidencedWatchInput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidencedWatchInput.js","sources":["../../../../src/core/transform/watch/evidencedWatchInput.ts"],"sourcesContent":[null],"names":["derivationIdentity","selectPluginSourceInputs","MISSING_INPUT_STATE","toProjectKey"],"mappings":";;;;;;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,mBAAmB,CACjC,MAAkC,EAClC,KAA6B,EAC7B,KAAa,EACb,KAAgC,EAAA;AAEhC,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,mBAAmB,IAAI,EAAE;IACjD,MAAM,QAAQ,GAAGA,qCAAkB,CAAC,KAAK,EAAE,KAAK,CAAC;IACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;;;AAGpC,IAAA,MAAM,MAAM,GAAGC,iDAAwB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;AACpE,IAAA,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,OAAO;AACL,YAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;AAClB,YAAA,QAAQ,EAAE;gBACR,QAAQ;AACR,gBAAA,OAAO,EAAE,KAAK;AACd,gBAAA,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE;AACjC,aAAA;SACF;IACH;IACA,MAAM,WAAW,GAAG,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC;AAChE,IAAA,MAAM,OAAO,GACX,WAAW,EAAE,UAAU,KAAK,KAAK;AACjC,QAAA,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,IAAI,KAAK,IAAI;AACrD,QAAA,QAAQ,CAAC,QAAQ,CAAC,KAAKC,uCAAmB;AAC5C,IAAA,MAAM,UAAU,GAAGC,yBAAY,CAC7B,MAAM,CAAC,WAAW,EAClB,KAAK,EACL,KAAK,CAAC,eAAe,CACtB;AACD,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ;AAC1E,UAAE,QAAQ,CAAC,QAAQ;UACjB,SAAS;AACb,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CACtD,MAAM,CAAC,WAAW,EAClB,UAAU;AAEV,UAAE,MAAM,CAAC,WAAW,CAAC,UAAU;UAC7B,SAAS;AACb,IAAA,MAAM,cAAc,GAAG,MAAM,CAAC,sBAAsB,IAAI,EAAE;AAC1D,IAAA,MAAM,aAAa,GACjB,WAAW,KAAK;AACd,UAAE,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW;UAClC,YAAY,KAAK,SAAS;YACxB,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,QAAQ;AAC/D,cAAE;AACE,gBAAA,KAAK,EAAE,OAAO;AACd,gBAAA,IAAI,EAAE,YAAY;AAClB,gBAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC,IAAI,IAAI;AAC3C;cACD,YAAY,KAAK;kBACf,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY;kBACnC,WAAW,KAAK;sBACd,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW;sBAClC,SAAS;IACrB,OAAO;AACL,QAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;AAClB,QAAA,QAAQ,EAAE;YACR,QAAQ;YACR,OAAO;AACP,YAAA,IAAI,aAAa,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC;AAChE,YAAA,WAAW,EACT,WAAW,EAAE,UAAU,KAAK;AAC1B,kBAAE;AACF,kBAAE;AACA,sBAAE;AACF,sBAAE,SAAS;AAClB,SAAA;KACF;AACH;;;;"}

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

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { derivationIdentity } from '../envelope/derivationIdentity.mjs';
+import { selectPluginSourceInputs } from '../envelope/selectPluginSourceInputs.mjs';
+import { toProjectKey } from '../project/toProjectKey.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+
+/**
+ * One input as a watch input, carrying identity from the generation's qualified
+ * native context and the state it recorded for the path: the compiler's
+ * predicate observation where it made one, the graph's hash and realpath for a
+ * realized input, the host bytes' hash for a walk or dependency-only input, or
+ * the state of a plugin source directory.
+ *
+ * State payloads are retained generation observations; identity queries share
+ * the generation context but a first spelling can still require native reads. A
+ * plugin source state takes precedence over other recorded codecs. An input
+ * with no recorded state returns `state` absent, leaving its caller to decide
+ * whether another observation is appropriate. No current byte read here
+ * manufactures evaluation-time state.
+ *
+ * @param spell The registration spelling callback. Predicate lookup uses the
+ *   native absolute lexical input; hash dictionaries use physical identity or
+ *   project keys without discarding the predicate's original spelling.
+ * @evidence contracts/common.md#principled-implementation Recorded plugin tree state takes precedence, then exact lexical predicates, external graph/host state and project host bytes. Own-entry hash guards preserve absent baselines; unknown state stays absent, with physical target/availability separate from registration spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One derivation maps retained generation facts into the documented watch carrier while the caller supplies its spelling policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown codec state stays absent; the missing marker is a supported observation value rather than a guessed content hash.
+ * @evidence contracts/common.md#meaningful-documentation Native prose describes generation evidence and spelling ownership, followed by separated acknowledgment tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve and the generation's identity context preserve actual filesystem identity separately from caller-selected lexical spelling.
+ * @evidence contracts/performance.md#efficient-algorithms Each call allocates one carrier and performs lexical/identity queries plus a plugin-source lookup; a first plugin lookup may parse the full declared source record. Non-tree inputs also compute the project key before selecting the recorded codec. Cost includes key/path text, any cold native path/ancestor/case observations and one caller spelling callback, while recorded byte hashes are not reread. Shared context/plugin populations remain owner costs beyond this fixed carrier allocation.
+ * @evidence contracts/performance.md#reuse-equivalent-work Recorded hashes/predicates and plugin state come from one immutable generation. Identity and project-key queries share its context under a still-valid native view and fixed root; this operation creates a fresh carrier rather than memoizing it, and cannot certify those premises independently.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mapping stores no new persistent cache or handle; retained generation facts belong to the generation owner.
+ */
+function evidencedWatchInput(cached, state, input, spell) {
+    const external = cached.externalInputHashes ?? {};
+    const identity = derivationIdentity(state, input);
+    const spelling = path.resolve(input);
+    // A plugin's source directory is proven by the state its binary was built
+    // from, whatever else observed the path (samchon/ttsc#1487).
+    const digest = selectPluginSourceInputs(cached.result).get(spelling);
+    if (digest !== undefined) {
+        return {
+            file: spell(input),
+            evidence: {
+                identity,
+                missing: false,
+                state: { codec: "tree", digest },
+            },
+        };
+    }
+    const observation = cached.externalInputObservations?.[spelling];
+    const missing = observation?.fileExists === false ||
+        state.graph?.inputProofs.get(spelling)?.hash === null ||
+        external[identity] === MISSING_INPUT_STATE;
+    const projectKey = toProjectKey(cached.projectRoot, input, state.identityContext);
+    const externalHash = Object.prototype.hasOwnProperty.call(external, identity)
+        ? external[identity]
+        : undefined;
+    const projectHash = Object.prototype.hasOwnProperty.call(cached.inputHashes, projectKey)
+        ? cached.inputHashes[projectKey]
+        : undefined;
+    const graphRealpaths = cached.externalInputRealpaths ?? {};
+    const stateEvidence = observation !== undefined
+        ? { codec: "predicates", observation }
+        : externalHash !== undefined &&
+            Object.prototype.hasOwnProperty.call(graphRealpaths, identity)
+            ? {
+                codec: "graph",
+                hash: externalHash,
+                realpath: graphRealpaths[identity] ?? null,
+            }
+            : externalHash !== undefined
+                ? { codec: "host", hash: externalHash }
+                : projectHash !== undefined
+                    ? { codec: "host", hash: projectHash }
+                    : undefined;
+    return {
+        file: spell(input),
+        evidence: {
+            identity,
+            missing,
+            ...(stateEvidence === undefined ? {} : { state: stateEvidence }),
+            unavailable: observation?.fileExists === false
+                ? "not-file"
+                : missing
+                    ? "missing"
+                    : undefined,
+        },
+    };
+}
+
+export { evidencedWatchInput };
+//# sourceMappingURL=evidencedWatchInput.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidencedWatchInput.mjs","sources":["../../../../src/core/transform/watch/evidencedWatchInput.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,mBAAmB,CACjC,MAAkC,EAClC,KAA6B,EAC7B,KAAa,EACb,KAAgC,EAAA;AAEhC,IAAA,MAAM,QAAQ,GAAG,MAAM,CAAC,mBAAmB,IAAI,EAAE;IACjD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC;IACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;;;AAGpC,IAAA,MAAM,MAAM,GAAG,wBAAwB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;AACpE,IAAA,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,OAAO;AACL,YAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;AAClB,YAAA,QAAQ,EAAE;gBACR,QAAQ;AACR,gBAAA,OAAO,EAAE,KAAK;AACd,gBAAA,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE;AACjC,aAAA;SACF;IACH;IACA,MAAM,WAAW,GAAG,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC;AAChE,IAAA,MAAM,OAAO,GACX,WAAW,EAAE,UAAU,KAAK,KAAK;AACjC,QAAA,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,IAAI,KAAK,IAAI;AACrD,QAAA,QAAQ,CAAC,QAAQ,CAAC,KAAK,mBAAmB;AAC5C,IAAA,MAAM,UAAU,GAAG,YAAY,CAC7B,MAAM,CAAC,WAAW,EAClB,KAAK,EACL,KAAK,CAAC,eAAe,CACtB;AACD,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ;AAC1E,UAAE,QAAQ,CAAC,QAAQ;UACjB,SAAS;AACb,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CACtD,MAAM,CAAC,WAAW,EAClB,UAAU;AAEV,UAAE,MAAM,CAAC,WAAW,CAAC,UAAU;UAC7B,SAAS;AACb,IAAA,MAAM,cAAc,GAAG,MAAM,CAAC,sBAAsB,IAAI,EAAE;AAC1D,IAAA,MAAM,aAAa,GACjB,WAAW,KAAK;AACd,UAAE,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW;UAClC,YAAY,KAAK,SAAS;YACxB,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,QAAQ;AAC/D,cAAE;AACE,gBAAA,KAAK,EAAE,OAAO;AACd,gBAAA,IAAI,EAAE,YAAY;AAClB,gBAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC,IAAI,IAAI;AAC3C;cACD,YAAY,KAAK;kBACf,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY;kBACnC,WAAW,KAAK;sBACd,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW;sBAClC,SAAS;IACrB,OAAO;AACL,QAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;AAClB,QAAA,QAAQ,EAAE;YACR,QAAQ;YACR,OAAO;AACP,YAAA,IAAI,aAAa,KAAK,SAAS,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC;AAChE,YAAA,WAAW,EACT,WAAW,EAAE,UAAU,KAAK;AAC1B,kBAAE;AACF,kBAAE;AACA,sBAAE;AACF,sBAAE,SAAS;AAClB,SAAA;KACF;AACH;;;;"}

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

@@ -0,0 +1,33 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscWatchInput } from "./TtscWatchInput.cjs";
+/**
+ * Every input of a generation, with the evidence it recorded: what the
+ * project's record holds and a watching session's bridge observes.
+ *
+ * The record uses a conservative generation-wide selection: every realized or
+ * resolver-input path of the graph (edge sources and targets, globals, the
+ * config chain, resolution inputs, and every candidate), every plugin-reported
+ * dependency, universal host input and plugin source directory. Graph sources
+ * are retained directly even when a per-file list excludes its own delivered
+ * spelling or admits a complete plugin declaration. This is not an exact union
+ * of all narrowed per-file watch lists. The disposed transform scratch tree is
+ * dropped, and so is the temporary tsconfig the compile ran under.
+ *
+ * Memoized per generation. Project-record delivery can separately add configs
+ * consulted while routing another module; this generation-wide input union
+ * retains one readonly snapshot. Consumers must not mutate its array or
+ * entries.
+ *
+ * Every path is the compiler's own spelling: the record is read by the adapter
+ * alone, and the host is handed only the record.
+ *
+ * @evidence contracts/common.md#principled-implementation The union covers compiler graph, reported dependencies, host inputs and plugin-source roots while excluding disposed scratch and temporary configuration paths.
+ * @evidence contracts/common.md#clear-and-simple-design A single append boundary centralizes lexical deduplication and evidence mapping; the memo returns one generation-wide readonly snapshot.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Scratch exclusion reflects disposed ownership, and dependency entries are validated before path use rather than supplemented with consumer-specific guesses.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains generation-wide derivation and memoization; callers must treat the returned array and its entries as immutable, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and generation identity preserve filesystem semantics; lexical spellings remain distinct registration keys even when their physical identities agree.
+ * @evidence contracts/performance.md#efficient-algorithms Cold selection can build graph and plugin-source indexes before scanning graph member spellings, every dependency occurrence and host/plugin lists. Each occurrence pays lexical path/scratch/key work; unique inputs additionally derive evidence with native identity/project-key queries and any cold observation costs. Temporary member arrays/indexes and output grow with producer/query populations and retained text; duplicates skip evidence conversion only after append checks. A completed generation snapshot needs only WeakMap entry selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work The WeakMap shares the completed input union by cached-generation identity. Result/root/scratch/temporary options, recorded evidence and its native identity view must remain valid for that generation; callers must not mutate the shared array or entries. A new cached generation receives a distinct selection without granting freshness from this memo alone.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The owner retains one input array per cached generation, containing unique lexical keys, evidence carriers and references to recorded payloads; sizes follow selected populations and text without a byte cap. Weak keys do not keep generations alive, but a borrower can retain the array/evidence after generation release. Shared derivation indexes have their own state owner; no watcher handle is acquired here.
+ */
+export declare function generationWatchInputs(cached: TtscCachedProjectTransform): readonly TtscWatchInput[];

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

@@ -0,0 +1,33 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscWatchInput } from "./TtscWatchInput.mjs";
+/**
+ * Every input of a generation, with the evidence it recorded: what the
+ * project's record holds and a watching session's bridge observes.
+ *
+ * The record uses a conservative generation-wide selection: every realized or
+ * resolver-input path of the graph (edge sources and targets, globals, the
+ * config chain, resolution inputs, and every candidate), every plugin-reported
+ * dependency, universal host input and plugin source directory. Graph sources
+ * are retained directly even when a per-file list excludes its own delivered
+ * spelling or admits a complete plugin declaration. This is not an exact union
+ * of all narrowed per-file watch lists. The disposed transform scratch tree is
+ * dropped, and so is the temporary tsconfig the compile ran under.
+ *
+ * Memoized per generation. Project-record delivery can separately add configs
+ * consulted while routing another module; this generation-wide input union
+ * retains one readonly snapshot. Consumers must not mutate its array or
+ * entries.
+ *
+ * Every path is the compiler's own spelling: the record is read by the adapter
+ * alone, and the host is handed only the record.
+ *
+ * @evidence contracts/common.md#principled-implementation The union covers compiler graph, reported dependencies, host inputs and plugin-source roots while excluding disposed scratch and temporary configuration paths.
+ * @evidence contracts/common.md#clear-and-simple-design A single append boundary centralizes lexical deduplication and evidence mapping; the memo returns one generation-wide readonly snapshot.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Scratch exclusion reflects disposed ownership, and dependency entries are validated before path use rather than supplemented with consumer-specific guesses.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains generation-wide derivation and memoization; callers must treat the returned array and its entries as immutable, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and generation identity preserve filesystem semantics; lexical spellings remain distinct registration keys even when their physical identities agree.
+ * @evidence contracts/performance.md#efficient-algorithms Cold selection can build graph and plugin-source indexes before scanning graph member spellings, every dependency occurrence and host/plugin lists. Each occurrence pays lexical path/scratch/key work; unique inputs additionally derive evidence with native identity/project-key queries and any cold observation costs. Temporary member arrays/indexes and output grow with producer/query populations and retained text; duplicates skip evidence conversion only after append checks. A completed generation snapshot needs only WeakMap entry selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work The WeakMap shares the completed input union by cached-generation identity. Result/root/scratch/temporary options, recorded evidence and its native identity view must remain valid for that generation; callers must not mutate the shared array or entries. A new cached generation receives a distinct selection without granting freshness from this memo alone.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The owner retains one input array per cached generation, containing unique lexical keys, evidence carriers and references to recorded payloads; sizes follow selected populations and text without a byte cap. Weak keys do not keep generations alive, but a borrower can retain the array/evidence after generation release. Shared derivation indexes have their own state owner; no watcher handle is acquired here.
+ */
+export declare function generationWatchInputs(cached: TtscCachedProjectTransform): readonly TtscWatchInput[];

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

@@ -0,0 +1,33 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscWatchInput } from "./TtscWatchInput";
+/**
+ * Every input of a generation, with the evidence it recorded: what the
+ * project's record holds and a watching session's bridge observes.
+ *
+ * The record uses a conservative generation-wide selection: every realized or
+ * resolver-input path of the graph (edge sources and targets, globals, the
+ * config chain, resolution inputs, and every candidate), every plugin-reported
+ * dependency, universal host input and plugin source directory. Graph sources
+ * are retained directly even when a per-file list excludes its own delivered
+ * spelling or admits a complete plugin declaration. This is not an exact union
+ * of all narrowed per-file watch lists. The disposed transform scratch tree is
+ * dropped, and so is the temporary tsconfig the compile ran under.
+ *
+ * Memoized per generation. Project-record delivery can separately add configs
+ * consulted while routing another module; this generation-wide input union
+ * retains one readonly snapshot. Consumers must not mutate its array or
+ * entries.
+ *
+ * Every path is the compiler's own spelling: the record is read by the adapter
+ * alone, and the host is handed only the record.
+ *
+ * @evidence contracts/common.md#principled-implementation The union covers compiler graph, reported dependencies, host inputs and plugin-source roots while excluding disposed scratch and temporary configuration paths.
+ * @evidence contracts/common.md#clear-and-simple-design A single append boundary centralizes lexical deduplication and evidence mapping; the memo returns one generation-wide readonly snapshot.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Scratch exclusion reflects disposed ownership, and dependency entries are validated before path use rather than supplemented with consumer-specific guesses.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains generation-wide derivation and memoization; callers must treat the returned array and its entries as immutable, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and generation identity preserve filesystem semantics; lexical spellings remain distinct registration keys even when their physical identities agree.
+ * @evidence contracts/performance.md#efficient-algorithms Cold selection can build graph and plugin-source indexes before scanning graph member spellings, every dependency occurrence and host/plugin lists. Each occurrence pays lexical path/scratch/key work; unique inputs additionally derive evidence with native identity/project-key queries and any cold observation costs. Temporary member arrays/indexes and output grow with producer/query populations and retained text; duplicates skip evidence conversion only after append checks. A completed generation snapshot needs only WeakMap entry selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work The WeakMap shares the completed input union by cached-generation identity. Result/root/scratch/temporary options, recorded evidence and its native identity view must remain valid for that generation; callers must not mutate the shared array or entries. A new cached generation receives a distinct selection without granting freshness from this memo alone.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The owner retains one input array per cached generation, containing unique lexical keys, evidence carriers and references to recorded payloads; sizes follow selected populations and text without a byte cap. Weak keys do not keep generations alive, but a borrower can retain the array/evidence after generation release. Shared derivation indexes have their own state owner; no watcher handle is acquired here.
+ */
+export declare function generationWatchInputs(cached: TtscCachedProjectTransform): readonly TtscWatchInput[];