@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,44 @@
+import path from 'node:path';
+
+/**
+ * The plugin source directories of a generation, each with the state the
+ * envelope reported for it, by absolute spelling (samchon/ttsc#1487).
+ *
+ * A plugin's binary is keyed on its Go source and the environment a build there
+ * runs in, so the generation's output is a function of these directories as
+ * much as of its host inputs: they are universal inputs of every module, proven
+ * by state (`pluginSourceHolds`, samchon/ttsc#1493) and observed as whole
+ * subtrees. A malformed entry is left out, since a state that is not a string
+ * proves nothing. Read once per envelope, since every watch input of every
+ * module asks it.
+ *
+ * @param result The generation's envelope.
+ * @evidence contracts/common.md#principled-implementation Each valid producer directory/digest pair records a universal plugin-build input; exceptions and malformed entries contribute no proven state rather than implying an empty subtree is unchanged.
+ * @evidence contracts/common.md#clear-and-simple-design One weakly memoized map exposes absolute directory spellings and their reported states; subtree observation and digest validation remain with the consuming cache/watch owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Digest values come from the actual envelope and are not recomputed later to retroactively certify the compile; non-string values cannot masquerade as a source-state proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain why plugin source trees are universal inputs, what malformed entries mean and generation memoization, with parameter and tag separation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve supplies absolute source-directory spellings; no OS-specific directory names, separator rewriting or case assumptions are introduced by the map adapter.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources WeakMap ownership releases the map with its result object; entries grow only with valid producer directories and this adapter does not acquire subtree observers or retain older generations.
+ * @evidence contracts/performance.md#efficient-algorithms One pass over pluginSources builds the map once per result, and repeated module queries use the WeakMap instead of rescanning source directories.
+ * @evidence contracts/performance.md#reuse-equivalent-work The immutable result object identifies equivalent source-state requests; fresh generation objects build fresh maps, and consumers must not mutate the returned read-only map.
+ */
+function selectPluginSourceInputs(result) {
+    const memo = PLUGIN_SOURCE_INPUTS.get(result);
+    if (memo !== undefined)
+        return memo;
+    const inputs = new Map();
+    PLUGIN_SOURCE_INPUTS.set(result, inputs);
+    if (result.type === "exception")
+        return inputs;
+    for (const [directory, digest] of Object.entries(result.pluginSources ?? {})) {
+        if (typeof digest !== "string" || directory.length === 0)
+            continue;
+        inputs.set(path.resolve(directory), digest);
+    }
+    return inputs;
+}
+/** The plugin source directories of each envelope, read once. */
+const PLUGIN_SOURCE_INPUTS = new WeakMap();
+
+export { selectPluginSourceInputs };
+//# sourceMappingURL=selectPluginSourceInputs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectPluginSourceInputs.mjs","sources":["../../../../src/core/transform/envelope/selectPluginSourceInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,wBAAwB,CACtC,MAAmC,EAAA;IAEnC,MAAM,IAAI,GAAG,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC;IAC7C,IAAI,IAAI,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACnC,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB;AACxC,IAAA,oBAAoB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;AACxC,IAAA,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW;AAAE,QAAA,OAAO,MAAM;AAC9C,IAAA,KAAK,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAC9C,MAAM,CAAC,aAAa,IAAI,EAAE,CAC3B,EAAE;QACD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE;AAC1D,QAAA,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC7C;AACA,IAAA,OAAO,MAAM;AACf;AAEA;AACA,MAAM,oBAAoB,GAAG,IAAI,OAAO,EAGrC;;;;"}

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

@@ -0,0 +1,22 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.cjs";
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
+ *
+ * Traversal coalesces physical vertices using the supplied generation context;
+ * the first reached target spelling is retained. The starting identity is
+ * marked before traversal, so cycles never reintroduce it into the output.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first worklist and identity visited set enumerate each reachable vertex once; premarking the start removes it even when a cycle returns to the same file through an alias.
+ * @evidence contracts/common.md#clear-and-simple-design One local stack, visited set and output array expose closure traversal over the already-built adjacency map; graph parsing and identity semantics remain with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cycle prevention follows visited identity rather than a depth cap, retry chain or special source name; target spellings are taken from actual graph edges.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state starting-file exclusion, shared indexing, physical vertex equivalence and first-target spelling, with acknowledgment separation under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Every queried source or target spelling passes through the generation's native identity context. Cold spellings can require realpath, ancestor and actual case observations; this traversal does not replace that boundary with lexical equality or an OS-name case rule. The supplied absolute spellings and context must describe the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal retains no history or handles; its returned array is caller-owned and its stack and visited set are local to one invocation.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Identity and Map/Set queries also pay spelling/key text hashing or comparison, and cold spellings add native path/ancestor/case observations. Stack, visited identities and output grow with reached vertices and retained text; duplicate edge spellings still require identity queries.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This closure operation owns no cross-request cache; selectWatchInputs owns final per-spelling reuse and envelopeGraphIndexes owns shared adjacency reuse.
+ */
+export declare function selectReachableEdges(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,22 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.mjs";
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
+ *
+ * Traversal coalesces physical vertices using the supplied generation context;
+ * the first reached target spelling is retained. The starting identity is
+ * marked before traversal, so cycles never reintroduce it into the output.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first worklist and identity visited set enumerate each reachable vertex once; premarking the start removes it even when a cycle returns to the same file through an alias.
+ * @evidence contracts/common.md#clear-and-simple-design One local stack, visited set and output array expose closure traversal over the already-built adjacency map; graph parsing and identity semantics remain with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cycle prevention follows visited identity rather than a depth cap, retry chain or special source name; target spellings are taken from actual graph edges.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state starting-file exclusion, shared indexing, physical vertex equivalence and first-target spelling, with acknowledgment separation under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Every queried source or target spelling passes through the generation's native identity context. Cold spellings can require realpath, ancestor and actual case observations; this traversal does not replace that boundary with lexical equality or an OS-name case rule. The supplied absolute spellings and context must describe the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal retains no history or handles; its returned array is caller-owned and its stack and visited set are local to one invocation.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Identity and Map/Set queries also pay spelling/key text hashing or comparison, and cold spellings add native path/ancestor/case observations. Stack, visited identities and output grow with reached vertices and retained text; duplicate edge spellings still require identity queries.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This closure operation owns no cross-request cache; selectWatchInputs owns final per-spelling reuse and envelopeGraphIndexes owns shared adjacency reuse.
+ */
+export declare function selectReachableEdges(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,22 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes";
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
+ *
+ * Traversal coalesces physical vertices using the supplied generation context;
+ * the first reached target spelling is retained. The starting identity is
+ * marked before traversal, so cycles never reintroduce it into the output.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first worklist and identity visited set enumerate each reachable vertex once; premarking the start removes it even when a cycle returns to the same file through an alias.
+ * @evidence contracts/common.md#clear-and-simple-design One local stack, visited set and output array expose closure traversal over the already-built adjacency map; graph parsing and identity semantics remain with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cycle prevention follows visited identity rather than a depth cap, retry chain or special source name; target spellings are taken from actual graph edges.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state starting-file exclusion, shared indexing, physical vertex equivalence and first-target spelling, with acknowledgment separation under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Every queried source or target spelling passes through the generation's native identity context. Cold spellings can require realpath, ancestor and actual case observations; this traversal does not replace that boundary with lexical equality or an OS-name case rule. The supplied absolute spellings and context must describe the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal retains no history or handles; its returned array is caller-owned and its stack and visited set are local to one invocation.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Identity and Map/Set queries also pay spelling/key text hashing or comparison, and cold spellings add native path/ancestor/case observations. Stack, visited identities and output grow with reached vertices and retained text; duplicate edge spellings still require identity queries.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This closure operation owns no cross-request cache; selectWatchInputs owns final per-spelling reuse and envelopeGraphIndexes owns shared adjacency reuse.
+ */
+export declare function selectReachableEdges(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,45 @@
+'use strict';
+
+var derivationIdentity = require('./derivationIdentity.js');
+
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
+ *
+ * Traversal coalesces physical vertices using the supplied generation context;
+ * the first reached target spelling is retained. The starting identity is
+ * marked before traversal, so cycles never reintroduce it into the output.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first worklist and identity visited set enumerate each reachable vertex once; premarking the start removes it even when a cycle returns to the same file through an alias.
+ * @evidence contracts/common.md#clear-and-simple-design One local stack, visited set and output array expose closure traversal over the already-built adjacency map; graph parsing and identity semantics remain with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cycle prevention follows visited identity rather than a depth cap, retry chain or special source name; target spellings are taken from actual graph edges.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state starting-file exclusion, shared indexing, physical vertex equivalence and first-target spelling, with acknowledgment separation under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Every queried source or target spelling passes through the generation's native identity context. Cold spellings can require realpath, ancestor and actual case observations; this traversal does not replace that boundary with lexical equality or an OS-name case rule. The supplied absolute spellings and context must describe the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal retains no history or handles; its returned array is caller-owned and its stack and visited set are local to one invocation.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Identity and Map/Set queries also pay spelling/key text hashing or comparison, and cold spellings add native path/ancestor/case observations. Stack, visited identities and output grow with reached vertices and retained text; duplicate edge spellings still require identity queries.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This closure operation owns no cross-request cache; selectWatchInputs owns final per-spelling reuse and envelopeGraphIndexes owns shared adjacency reuse.
+ */
+function selectReachableEdges(graph, state, file) {
+    const output = [];
+    const visited = new Set([derivationIdentity.derivationIdentity(state, file)]);
+    const queue = [file];
+    while (queue.length !== 0) {
+        const current = queue.pop();
+        for (const target of graph.edges.get(derivationIdentity.derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity.derivationIdentity(state, target);
+            if (visited.has(identity)) {
+                continue;
+            }
+            visited.add(identity);
+            queue.push(target);
+            output.push(target);
+        }
+    }
+    return output;
+}
+
+exports.selectReachableEdges = selectReachableEdges;
+//# sourceMappingURL=selectReachableEdges.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReachableEdges.js","sources":["../../../../src/core/transform/envelope/selectReachableEdges.ts"],"sourcesContent":[null],"names":["derivationIdentity"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;SACa,oBAAoB,CAClC,KAA+B,EAC/B,KAA6B,EAC7B,IAAY,EAAA;IAEZ,MAAM,MAAM,GAAa,EAAE;AAC3B,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAACA,qCAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,IAAA,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC;AACpB,IAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG;AAC5B,QAAA,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAACA,qCAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACtE,YAAA,EAAE,EAAE;YACJ,MAAM,QAAQ,GAAGA,qCAAkB,CAAC,KAAK,EAAE,MAAM,CAAC;AAClD,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBACzB;YACF;AACA,YAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;AACrB,YAAA,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;AAClB,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;QACrB;IACF;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,43 @@
+import { derivationIdentity } from './derivationIdentity.mjs';
+
+/**
+ * Walk the reachability closure of the graph's direct `edges` from `file`,
+ * returning the absolute path of every file reached (the starting file itself
+ * excluded, even when a cycle points back at it). Reads the shared per-envelope
+ * edge index instead of rebuilding it per delivery.
+ *
+ * Traversal coalesces physical vertices using the supplied generation context;
+ * the first reached target spelling is retained. The starting identity is
+ * marked before traversal, so cycles never reintroduce it into the output.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first worklist and identity visited set enumerate each reachable vertex once; premarking the start removes it even when a cycle returns to the same file through an alias.
+ * @evidence contracts/common.md#clear-and-simple-design One local stack, visited set and output array expose closure traversal over the already-built adjacency map; graph parsing and identity semantics remain with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cycle prevention follows visited identity rather than a depth cap, retry chain or special source name; target spellings are taken from actual graph edges.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs state starting-file exclusion, shared indexing, physical vertex equivalence and first-target spelling, with acknowledgment separation under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Every queried source or target spelling passes through the generation's native identity context. Cold spellings can require realpath, ancestor and actual case observations; this traversal does not replace that boundary with lexical equality or an OS-name case rule. The supplied absolute spellings and context must describe the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The traversal retains no history or handles; its returned array is caller-owned and its stack and visited set are local to one invocation.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Identity and Map/Set queries also pay spelling/key text hashing or comparison, and cold spellings add native path/ancestor/case observations. Stack, visited identities and output grow with reached vertices and retained text; duplicate edge spellings still require identity queries.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This closure operation owns no cross-request cache; selectWatchInputs owns final per-spelling reuse and envelopeGraphIndexes owns shared adjacency reuse.
+ */
+function selectReachableEdges(graph, state, file) {
+    const output = [];
+    const visited = new Set([derivationIdentity(state, file)]);
+    const queue = [file];
+    while (queue.length !== 0) {
+        const current = queue.pop();
+        for (const target of graph.edges.get(derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity(state, target);
+            if (visited.has(identity)) {
+                continue;
+            }
+            visited.add(identity);
+            queue.push(target);
+            output.push(target);
+        }
+    }
+    return output;
+}
+
+export { selectReachableEdges };
+//# sourceMappingURL=selectReachableEdges.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReachableEdges.mjs","sources":["../../../../src/core/transform/envelope/selectReachableEdges.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;SACa,oBAAoB,CAClC,KAA+B,EAC/B,KAA6B,EAC7B,IAAY,EAAA;IAEZ,MAAM,MAAM,GAAa,EAAE;AAC3B,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,IAAA,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC;AACpB,IAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG;AAC5B,QAAA,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACtE,YAAA,EAAE,EAAE;YACJ,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC;AAClD,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBACzB;YACF;AACA,YAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;AACrB,YAAA,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;AAClB,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;QACrB;IACF;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.cjs";
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ *
+ * The first element keeps the caller's spelling of `file`; newly reached
+ * identities use the graph's source spelling when available. This includes a
+ * source exactly once by physical identity even if cycles or aliases reach it.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first visited-identity traversal includes the start and every reachable importer exactly once, using source spellings so candidate ownership is resolved from importer identity rather than target text.
+ * @evidence contracts/common.md#clear-and-simple-design The source-closure selector differs visibly from target-edge selection only in including the start and choosing source spellings, reflecting their distinct consumer semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Physical visited identities handle cycles and aliases without arbitrary traversal cutoffs or importer-name exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain importer ownership, start inclusion, spelling choice and cycle/alias behavior with separate acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The start and queried edge spellings use the generation's native identity context, including cold realpath, ancestor and actual case observations. Graph source spellings select presentation after native identity admission; they do not establish identity by lexical text. The supplied absolute spellings and context must represent the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the caller-owned output array escapes; the worklist and visited set are local, with no retained history, watchers or file handles.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Spelling/key text hashing or comparison and cold native path/ancestor/case observations add identity costs, including queries for duplicate edge spellings. Stack, visited identities and output retain reached-vertex populations and their text; source spelling selection is one additional Map query per newly reached identity.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This source closure is an invocation-local computation; per-delivery watch-list reuse belongs to selectWatchInputs and generation index reuse belongs to envelopeGraphIndexes.
+ */
+export declare function selectReachableSources(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.mjs";
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ *
+ * The first element keeps the caller's spelling of `file`; newly reached
+ * identities use the graph's source spelling when available. This includes a
+ * source exactly once by physical identity even if cycles or aliases reach it.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first visited-identity traversal includes the start and every reachable importer exactly once, using source spellings so candidate ownership is resolved from importer identity rather than target text.
+ * @evidence contracts/common.md#clear-and-simple-design The source-closure selector differs visibly from target-edge selection only in including the start and choosing source spellings, reflecting their distinct consumer semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Physical visited identities handle cycles and aliases without arbitrary traversal cutoffs or importer-name exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain importer ownership, start inclusion, spelling choice and cycle/alias behavior with separate acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The start and queried edge spellings use the generation's native identity context, including cold realpath, ancestor and actual case observations. Graph source spellings select presentation after native identity admission; they do not establish identity by lexical text. The supplied absolute spellings and context must represent the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the caller-owned output array escapes; the worklist and visited set are local, with no retained history, watchers or file handles.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Spelling/key text hashing or comparison and cold native path/ancestor/case observations add identity costs, including queries for duplicate edge spellings. Stack, visited identities and output retain reached-vertex populations and their text; source spelling selection is one additional Map query per newly reached identity.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This source closure is an invocation-local computation; per-delivery watch-list reuse belongs to selectWatchInputs and generation index reuse belongs to envelopeGraphIndexes.
+ */
+export declare function selectReachableSources(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes";
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ *
+ * The first element keeps the caller's spelling of `file`; newly reached
+ * identities use the graph's source spelling when available. This includes a
+ * source exactly once by physical identity even if cycles or aliases reach it.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first visited-identity traversal includes the start and every reachable importer exactly once, using source spellings so candidate ownership is resolved from importer identity rather than target text.
+ * @evidence contracts/common.md#clear-and-simple-design The source-closure selector differs visibly from target-edge selection only in including the start and choosing source spellings, reflecting their distinct consumer semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Physical visited identities handle cycles and aliases without arbitrary traversal cutoffs or importer-name exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain importer ownership, start inclusion, spelling choice and cycle/alias behavior with separate acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The start and queried edge spellings use the generation's native identity context, including cold realpath, ancestor and actual case observations. Graph source spellings select presentation after native identity admission; they do not establish identity by lexical text. The supplied absolute spellings and context must represent the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the caller-owned output array escapes; the worklist and visited set are local, with no retained history, watchers or file handles.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Spelling/key text hashing or comparison and cold native path/ancestor/case observations add identity costs, including queries for duplicate edge spellings. Stack, visited identities and output retain reached-vertex populations and their text; source spelling selection is one additional Map query per newly reached identity.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This source closure is an invocation-local computation; per-delivery watch-list reuse belongs to selectWatchInputs and generation index reuse belongs to envelopeGraphIndexes.
+ */
+export declare function selectReachableSources(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, file: string): string[];

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

@@ -0,0 +1,44 @@
+'use strict';
+
+var derivationIdentity = require('./derivationIdentity.js');
+
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ *
+ * The first element keeps the caller's spelling of `file`; newly reached
+ * identities use the graph's source spelling when available. This includes a
+ * source exactly once by physical identity even if cycles or aliases reach it.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first visited-identity traversal includes the start and every reachable importer exactly once, using source spellings so candidate ownership is resolved from importer identity rather than target text.
+ * @evidence contracts/common.md#clear-and-simple-design The source-closure selector differs visibly from target-edge selection only in including the start and choosing source spellings, reflecting their distinct consumer semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Physical visited identities handle cycles and aliases without arbitrary traversal cutoffs or importer-name exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain importer ownership, start inclusion, spelling choice and cycle/alias behavior with separate acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The start and queried edge spellings use the generation's native identity context, including cold realpath, ancestor and actual case observations. Graph source spellings select presentation after native identity admission; they do not establish identity by lexical text. The supplied absolute spellings and context must represent the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the caller-owned output array escapes; the worklist and visited set are local, with no retained history, watchers or file handles.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Spelling/key text hashing or comparison and cold native path/ancestor/case observations add identity costs, including queries for duplicate edge spellings. Stack, visited identities and output retain reached-vertex populations and their text; source spelling selection is one additional Map query per newly reached identity.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This source closure is an invocation-local computation; per-delivery watch-list reuse belongs to selectWatchInputs and generation index reuse belongs to envelopeGraphIndexes.
+ */
+function selectReachableSources(graph, state, file) {
+    const output = [file];
+    const visited = new Set([derivationIdentity.derivationIdentity(state, file)]);
+    const queue = [file];
+    while (queue.length !== 0) {
+        const current = queue.pop();
+        for (const target of graph.edges.get(derivationIdentity.derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity.derivationIdentity(state, target);
+            if (visited.has(identity)) {
+                continue;
+            }
+            visited.add(identity);
+            queue.push(target);
+            output.push(graph.spellings.get(identity) ?? target);
+        }
+    }
+    return output;
+}
+
+exports.selectReachableSources = selectReachableSources;
+//# sourceMappingURL=selectReachableSources.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReachableSources.js","sources":["../../../../src/core/transform/envelope/selectReachableSources.ts"],"sourcesContent":[null],"names":["derivationIdentity"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;SACa,sBAAsB,CACpC,KAA+B,EAC/B,KAA6B,EAC7B,IAAY,EAAA;AAEZ,IAAA,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC;AACrB,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAACA,qCAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,IAAA,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC;AACpB,IAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG;AAC5B,QAAA,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAACA,qCAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACtE,YAAA,EAAE,EAAE;YACJ,MAAM,QAAQ,GAAGA,qCAAkB,CAAC,KAAK,EAAE,MAAM,CAAC;AAClD,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBACzB;YACF;AACA,YAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;AACrB,YAAA,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;AAClB,YAAA,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC;QACtD;IACF;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,42 @@
+import { derivationIdentity } from './derivationIdentity.mjs';
+
+/**
+ * Return the source files whose direct graph edges are reachable from `file`,
+ * including `file` itself. Resolution candidates belong to importers rather
+ * than targets, so this is intentionally distinct from selectReachableEdges.
+ *
+ * The first element keeps the caller's spelling of `file`; newly reached
+ * identities use the graph's source spelling when available. This includes a
+ * source exactly once by physical identity even if cycles or aliases reach it.
+ *
+ * @evidence contracts/common.md#principled-implementation A depth-first visited-identity traversal includes the start and every reachable importer exactly once, using source spellings so candidate ownership is resolved from importer identity rather than target text.
+ * @evidence contracts/common.md#clear-and-simple-design The source-closure selector differs visibly from target-edge selection only in including the start and choosing source spellings, reflecting their distinct consumer semantics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Physical visited identities handle cycles and aliases without arbitrary traversal cutoffs or importer-name exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain importer ownership, start inclusion, spelling choice and cycle/alias behavior with separate acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The start and queried edge spellings use the generation's native identity context, including cold realpath, ancestor and actual case observations. Graph source spellings select presentation after native identity admission; they do not establish identity by lexical text. The supplied absolute spellings and context must represent the same stable generation view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the caller-owned output array escapes; the worklist and visited set are local, with no retained history, watchers or file handles.
+ * @evidence contracts/performance.md#efficient-algorithms Each reached identity is popped once and each reached adjacency entry scanned once, giving V + E structural operations. Spelling/key text hashing or comparison and cold native path/ancestor/case observations add identity costs, including queries for duplicate edge spellings. Stack, visited identities and output retain reached-vertex populations and their text; source spelling selection is one additional Map query per newly reached identity.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This source closure is an invocation-local computation; per-delivery watch-list reuse belongs to selectWatchInputs and generation index reuse belongs to envelopeGraphIndexes.
+ */
+function selectReachableSources(graph, state, file) {
+    const output = [file];
+    const visited = new Set([derivationIdentity(state, file)]);
+    const queue = [file];
+    while (queue.length !== 0) {
+        const current = queue.pop();
+        for (const target of graph.edges.get(derivationIdentity(state, current)) ??
+            []) {
+            const identity = derivationIdentity(state, target);
+            if (visited.has(identity)) {
+                continue;
+            }
+            visited.add(identity);
+            queue.push(target);
+            output.push(graph.spellings.get(identity) ?? target);
+        }
+    }
+    return output;
+}
+
+export { selectReachableSources };
+//# sourceMappingURL=selectReachableSources.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectReachableSources.mjs","sources":["../../../../src/core/transform/envelope/selectReachableSources.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;AAiBG;SACa,sBAAsB,CACpC,KAA+B,EAC/B,KAA6B,EAC7B,IAAY,EAAA;AAEZ,IAAA,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC;AACrB,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,IAAA,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC;AACpB,IAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG;AAC5B,QAAA,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACtE,YAAA,EAAE,EAAE;YACJ,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC;AAClD,YAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBACzB;YACF;AACA,YAAA,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;AACrB,YAAA,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;AAClB,YAAA,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC;QACtD;IACF;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.cjs";
+/**
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
+ *
+ * Importer entries and their source identities come from the shared
+ * per-envelope state. Selection traverses the reachable importers and scans
+ * recorded candidate entries without repeating compiler module resolution;
+ * newly queried path spellings can still require native identity observations.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal resolver inputs always contribute, and importer-owned candidate lists contribute only when their source identity belongs to the delivered file's reachable source closure, including the file itself.
+ * @evidence contracts/common.md#clear-and-simple-design Source closure, universal input copying and importer membership filtering are distinct stages over shared indexes; compiler resolution is not repeated here.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Plugin completeness cannot suppress compiler-owned resolver inputs, and absent graph/exception results produce no guessed resolution paths or substituted compiler answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain host ownership, completeness independence and shared importer identities; acknowledgment separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Reachable importer selection and its membership keys use derivationIdentity with the generation's native context. Cold spellings may read realpath, ancestor and actual case observations; candidate list spellings remain as recorded native absolute paths. Selection neither substitutes an OS-name case policy nor repeats compiler resolution, and requires the same stable generation view as its indexes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local reachable and output containers belong to one selection; no persistent state or watcher handles are acquired, and the returned array belongs to its caller.
+ * @evidence contracts/performance.md#efficient-algorithms Reachable-source traversal pays visited V + E structural work plus spelling/key text and cold native identity observations. Mapping those sources allocates another V-entry array before the membership set; one candidate-entry scan then appends universal and selected list members. Temporary arrays, sets and output scale with reachable sources, universal inputs, selected inputs and their retained text, without compiler module resolution.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector owns no request memo; shared candidate parsing belongs to envelopeGraphIndexes and final per-module list reuse belongs to selectWatchInputs.
+ */
+export declare function selectResolutionCandidateInputs(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): string[];

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.mjs";
+/**
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
+ *
+ * Importer entries and their source identities come from the shared
+ * per-envelope state. Selection traverses the reachable importers and scans
+ * recorded candidate entries without repeating compiler module resolution;
+ * newly queried path spellings can still require native identity observations.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal resolver inputs always contribute, and importer-owned candidate lists contribute only when their source identity belongs to the delivered file's reachable source closure, including the file itself.
+ * @evidence contracts/common.md#clear-and-simple-design Source closure, universal input copying and importer membership filtering are distinct stages over shared indexes; compiler resolution is not repeated here.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Plugin completeness cannot suppress compiler-owned resolver inputs, and absent graph/exception results produce no guessed resolution paths or substituted compiler answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain host ownership, completeness independence and shared importer identities; acknowledgment separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Reachable importer selection and its membership keys use derivationIdentity with the generation's native context. Cold spellings may read realpath, ancestor and actual case observations; candidate list spellings remain as recorded native absolute paths. Selection neither substitutes an OS-name case policy nor repeats compiler resolution, and requires the same stable generation view as its indexes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local reachable and output containers belong to one selection; no persistent state or watcher handles are acquired, and the returned array belongs to its caller.
+ * @evidence contracts/performance.md#efficient-algorithms Reachable-source traversal pays visited V + E structural work plus spelling/key text and cold native identity observations. Mapping those sources allocates another V-entry array before the membership set; one candidate-entry scan then appends universal and selected list members. Temporary arrays, sets and output scale with reachable sources, universal inputs, selected inputs and their retained text, without compiler module resolution.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector owns no request memo; shared candidate parsing belongs to envelopeGraphIndexes and final per-module list reuse belongs to selectWatchInputs.
+ */
+export declare function selectResolutionCandidateInputs(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): string[];

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

@@ -0,0 +1,28 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes";
+/**
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
+ *
+ * Importer entries and their source identities come from the shared
+ * per-envelope state. Selection traverses the reachable importers and scans
+ * recorded candidate entries without repeating compiler module resolution;
+ * newly queried path spellings can still require native identity observations.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal resolver inputs always contribute, and importer-owned candidate lists contribute only when their source identity belongs to the delivered file's reachable source closure, including the file itself.
+ * @evidence contracts/common.md#clear-and-simple-design Source closure, universal input copying and importer membership filtering are distinct stages over shared indexes; compiler resolution is not repeated here.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Plugin completeness cannot suppress compiler-owned resolver inputs, and absent graph/exception results produce no guessed resolution paths or substituted compiler answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain host ownership, completeness independence and shared importer identities; acknowledgment separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Reachable importer selection and its membership keys use derivationIdentity with the generation's native context. Cold spellings may read realpath, ancestor and actual case observations; candidate list spellings remain as recorded native absolute paths. Selection neither substitutes an OS-name case policy nor repeats compiler resolution, and requires the same stable generation view as its indexes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local reachable and output containers belong to one selection; no persistent state or watcher handles are acquired, and the returned array belongs to its caller.
+ * @evidence contracts/performance.md#efficient-algorithms Reachable-source traversal pays visited V + E structural work plus spelling/key text and cold native identity observations. Mapping those sources allocates another V-entry array before the membership set; one candidate-entry scan then appends universal and selected list members. Temporary arrays, sets and output scale with reachable sources, universal inputs, selected inputs and their retained text, without compiler module resolution.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector owns no request memo; shared candidate parsing belongs to envelopeGraphIndexes and final per-module list reuse belongs to selectWatchInputs.
+ */
+export declare function selectResolutionCandidateInputs(graph: TtscEnvelopeGraphIndexes, state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): string[];

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

@@ -0,0 +1,45 @@
+'use strict';
+
+var derivationIdentity = require('./derivationIdentity.js');
+var selectReachableSources = require('./selectReachableSources.js');
+
+/**
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
+ *
+ * Importer entries and their source identities come from the shared
+ * per-envelope state. Selection traverses the reachable importers and scans
+ * recorded candidate entries without repeating compiler module resolution;
+ * newly queried path spellings can still require native identity observations.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal resolver inputs always contribute, and importer-owned candidate lists contribute only when their source identity belongs to the delivered file's reachable source closure, including the file itself.
+ * @evidence contracts/common.md#clear-and-simple-design Source closure, universal input copying and importer membership filtering are distinct stages over shared indexes; compiler resolution is not repeated here.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Plugin completeness cannot suppress compiler-owned resolver inputs, and absent graph/exception results produce no guessed resolution paths or substituted compiler answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain host ownership, completeness independence and shared importer identities; acknowledgment separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Reachable importer selection and its membership keys use derivationIdentity with the generation's native context. Cold spellings may read realpath, ancestor and actual case observations; candidate list spellings remain as recorded native absolute paths. Selection neither substitutes an OS-name case policy nor repeats compiler resolution, and requires the same stable generation view as its indexes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local reachable and output containers belong to one selection; no persistent state or watcher handles are acquired, and the returned array belongs to its caller.
+ * @evidence contracts/performance.md#efficient-algorithms Reachable-source traversal pays visited V + E structural work plus spelling/key text and cold native identity observations. Mapping those sources allocates another V-entry array before the membership set; one candidate-entry scan then appends universal and selected list members. Temporary arrays, sets and output scale with reachable sources, universal inputs, selected inputs and their retained text, without compiler module resolution.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector owns no request memo; shared candidate parsing belongs to envelopeGraphIndexes and final per-module list reuse belongs to selectWatchInputs.
+ */
+function selectResolutionCandidateInputs(graph, state, props) {
+    if (props.result.type === "exception" || props.result.graph === undefined) {
+        return [];
+    }
+    const reachable = new Set(selectReachableSources.selectReachableSources(graph, state, props.file).map((source) => derivationIdentity.derivationIdentity(state, source)));
+    const output = [...graph.resolutionInputs];
+    if (props.result.graph.candidates === undefined)
+        return output;
+    for (const entry of graph.candidates) {
+        if (!reachable.has(entry.source)) {
+            continue;
+        }
+        for (const entryToAppend of entry.files)
+            output.push(entryToAppend);
+    }
+    return output;
+}
+
+exports.selectResolutionCandidateInputs = selectResolutionCandidateInputs;
+//# sourceMappingURL=selectResolutionCandidateInputs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectResolutionCandidateInputs.js","sources":["../../../../src/core/transform/envelope/selectResolutionCandidateInputs.ts"],"sourcesContent":[null],"names":["selectReachableSources","derivationIdentity"],"mappings":";;;;;AAOA;;;;;;;;;;;;;;;;;;;AAmBG;SACa,+BAA+B,CAC7C,KAA+B,EAC/B,KAA6B,EAC7B,KAIC,EAAA;AAED,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;AACzE,QAAA,OAAO,EAAE;IACX;AACA,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,CACvBA,6CAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,KAC1DC,qCAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAClC,CACF;IACD,MAAM,MAAM,GAAa,CAAC,GAAG,KAAK,CAAC,gBAAgB,CAAC;IACpD,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,KAAK,SAAS;AAAE,QAAA,OAAO,MAAM;AAC9D,IAAA,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,UAAU,EAAE;QACpC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YAChC;QACF;AACA,QAAA,KAAK,MAAM,aAAa,IAAI,KAAK,CAAC,KAAK;AAAE,YAAA,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;IACrE;AACA,IAAA,OAAO,MAAM;AACf;;;;"}

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

@@ -0,0 +1,43 @@
+import { derivationIdentity } from './derivationIdentity.mjs';
+import { selectReachableSources } from './selectReachableSources.mjs';
+
+/**
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
+ *
+ * Importer entries and their source identities come from the shared
+ * per-envelope state. Selection traverses the reachable importers and scans
+ * recorded candidate entries without repeating compiler module resolution;
+ * newly queried path spellings can still require native identity observations.
+ *
+ * @evidence contracts/common.md#principled-implementation Universal resolver inputs always contribute, and importer-owned candidate lists contribute only when their source identity belongs to the delivered file's reachable source closure, including the file itself.
+ * @evidence contracts/common.md#clear-and-simple-design Source closure, universal input copying and importer membership filtering are distinct stages over shared indexes; compiler resolution is not repeated here.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Plugin completeness cannot suppress compiler-owned resolver inputs, and absent graph/exception results produce no guessed resolution paths or substituted compiler answers.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain host ownership, completeness independence and shared importer identities; acknowledgment separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Reachable importer selection and its membership keys use derivationIdentity with the generation's native context. Cold spellings may read realpath, ancestor and actual case observations; candidate list spellings remain as recorded native absolute paths. Selection neither substitutes an OS-name case policy nor repeats compiler resolution, and requires the same stable generation view as its indexes.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local reachable and output containers belong to one selection; no persistent state or watcher handles are acquired, and the returned array belongs to its caller.
+ * @evidence contracts/performance.md#efficient-algorithms Reachable-source traversal pays visited V + E structural work plus spelling/key text and cold native identity observations. Mapping those sources allocates another V-entry array before the membership set; one candidate-entry scan then appends universal and selected list members. Temporary arrays, sets and output scale with reachable sources, universal inputs, selected inputs and their retained text, without compiler module resolution.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector owns no request memo; shared candidate parsing belongs to envelopeGraphIndexes and final per-module list reuse belongs to selectWatchInputs.
+ */
+function selectResolutionCandidateInputs(graph, state, props) {
+    if (props.result.type === "exception" || props.result.graph === undefined) {
+        return [];
+    }
+    const reachable = new Set(selectReachableSources(graph, state, props.file).map((source) => derivationIdentity(state, source)));
+    const output = [...graph.resolutionInputs];
+    if (props.result.graph.candidates === undefined)
+        return output;
+    for (const entry of graph.candidates) {
+        if (!reachable.has(entry.source)) {
+            continue;
+        }
+        for (const entryToAppend of entry.files)
+            output.push(entryToAppend);
+    }
+    return output;
+}
+
+export { selectResolutionCandidateInputs };
+//# sourceMappingURL=selectResolutionCandidateInputs.mjs.map