@ttsc/unplugin 0.30.4 → 0.31.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectResolutionCandidateInputs.mjs","sources":["../../../../src/core/transform/envelope/selectResolutionCandidateInputs.ts"],"sourcesContent":[null],"names":[],"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,CACvB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,KAC1D,kBAAkB,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/selectTransformedSource.d.cts

@@ -0,0 +1,43 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformedOutput } from "./TtscTransformedOutput.cjs";
+/**
+ * Extract the transformed source for a single file from the compiler result,
+ * with the source map the envelope carries for the same key.
+ *
+ * Throws on compiler exception or hard failure so the bundler surfaces the
+ * error to the user. On success, tries a fast exact-match lookup by
+ * project-relative key first, then falls back to a lazy first-match identity
+ * index when the key in `result.typescript` uses an absolute or
+ * differently-cased path. The map is read under the key the text was found
+ * under, so the two always describe the same envelope entry
+ * (samchon/ttsc#1392).
+ *
+ * @evidence contracts/common.md#principled-implementation The matched producer key selects both transformed text and its own source map, preventing provenance from another alias entry; exception/failure results and missing program output raise their distinct supported errors.
+ * @evidence contracts/common.md#clear-and-simple-design Result discrimination precedes lookup, a local output adapter binds code to map, and the shared identity index isolates alternate-spelling lookup from error reporting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback supports real producer key spelling differences with first-match precedence; absent output is reported rather than synthesized from original source or a different module's map.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe source/map coupling, error behavior and exact versus identity lookup; the acknowledgment block follows the documentation skill's spacing guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Project key matching and alternate key identities use the envelope's filesystem context, so physical aliases and native case behavior are not guessed from lowercased strings.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One key per physical output identity is retained in weakly owned envelope state; returned artifacts reference generation output, and this selector owns no independent handle or cross-generation history.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Successful lookup pays native project-key/path/identity work before an own
+ *   record probe. A first miss materializes output keys, key/value pairs and the
+ *   identity index, paying every key's text and uncached native observations;
+ *   later misses reuse it. Error routes format diagnostic/unknown-value text;
+ *   missing output also traverses reachable config references, reads their
+ *   selection data and constructs the path-list message. Costs follow those
+ *   populations, paths and content, not only the number of output keys.
+ * @evidence contracts/performance.md#reuse-equivalent-work The output index is reused only for the same immutable generation and project root; text and maps remain coupled by the saved producer key, not by an inferred equality of their contents.
+ */
+export declare function selectTransformedSource(props: {
+    /** Absolute native module spelling whose producer output is requested. */
+    file: string;
+    /**
+     * Stable generation root used by project keys and alternate producer
+     * spellings.
+     */
+    projectRoot: string;
+    /** Immutable compiler generation supplying coupled text and map records. */
+    result: ITtscCompilerTransformation;
+    /** Selected config address used only when reporting missing program output. */
+    tsconfig: string;
+}): TtscTransformedOutput;

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

@@ -0,0 +1,43 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformedOutput } from "./TtscTransformedOutput.mjs";
+/**
+ * Extract the transformed source for a single file from the compiler result,
+ * with the source map the envelope carries for the same key.
+ *
+ * Throws on compiler exception or hard failure so the bundler surfaces the
+ * error to the user. On success, tries a fast exact-match lookup by
+ * project-relative key first, then falls back to a lazy first-match identity
+ * index when the key in `result.typescript` uses an absolute or
+ * differently-cased path. The map is read under the key the text was found
+ * under, so the two always describe the same envelope entry
+ * (samchon/ttsc#1392).
+ *
+ * @evidence contracts/common.md#principled-implementation The matched producer key selects both transformed text and its own source map, preventing provenance from another alias entry; exception/failure results and missing program output raise their distinct supported errors.
+ * @evidence contracts/common.md#clear-and-simple-design Result discrimination precedes lookup, a local output adapter binds code to map, and the shared identity index isolates alternate-spelling lookup from error reporting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback supports real producer key spelling differences with first-match precedence; absent output is reported rather than synthesized from original source or a different module's map.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe source/map coupling, error behavior and exact versus identity lookup; the acknowledgment block follows the documentation skill's spacing guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Project key matching and alternate key identities use the envelope's filesystem context, so physical aliases and native case behavior are not guessed from lowercased strings.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One key per physical output identity is retained in weakly owned envelope state; returned artifacts reference generation output, and this selector owns no independent handle or cross-generation history.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Successful lookup pays native project-key/path/identity work before an own
+ *   record probe. A first miss materializes output keys, key/value pairs and the
+ *   identity index, paying every key's text and uncached native observations;
+ *   later misses reuse it. Error routes format diagnostic/unknown-value text;
+ *   missing output also traverses reachable config references, reads their
+ *   selection data and constructs the path-list message. Costs follow those
+ *   populations, paths and content, not only the number of output keys.
+ * @evidence contracts/performance.md#reuse-equivalent-work The output index is reused only for the same immutable generation and project root; text and maps remain coupled by the saved producer key, not by an inferred equality of their contents.
+ */
+export declare function selectTransformedSource(props: {
+    /** Absolute native module spelling whose producer output is requested. */
+    file: string;
+    /**
+     * Stable generation root used by project keys and alternate producer
+     * spellings.
+     */
+    projectRoot: string;
+    /** Immutable compiler generation supplying coupled text and map records. */
+    result: ITtscCompilerTransformation;
+    /** Selected config address used only when reporting missing program output. */
+    tsconfig: string;
+}): TtscTransformedOutput;

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

@@ -0,0 +1,43 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscTransformedOutput } from "./TtscTransformedOutput";
+/**
+ * Extract the transformed source for a single file from the compiler result,
+ * with the source map the envelope carries for the same key.
+ *
+ * Throws on compiler exception or hard failure so the bundler surfaces the
+ * error to the user. On success, tries a fast exact-match lookup by
+ * project-relative key first, then falls back to a lazy first-match identity
+ * index when the key in `result.typescript` uses an absolute or
+ * differently-cased path. The map is read under the key the text was found
+ * under, so the two always describe the same envelope entry
+ * (samchon/ttsc#1392).
+ *
+ * @evidence contracts/common.md#principled-implementation The matched producer key selects both transformed text and its own source map, preventing provenance from another alias entry; exception/failure results and missing program output raise their distinct supported errors.
+ * @evidence contracts/common.md#clear-and-simple-design Result discrimination precedes lookup, a local output adapter binds code to map, and the shared identity index isolates alternate-spelling lookup from error reporting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback supports real producer key spelling differences with first-match precedence; absent output is reported rather than synthesized from original source or a different module's map.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe source/map coupling, error behavior and exact versus identity lookup; the acknowledgment block follows the documentation skill's spacing guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Project key matching and alternate key identities use the envelope's filesystem context, so physical aliases and native case behavior are not guessed from lowercased strings.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One key per physical output identity is retained in weakly owned envelope state; returned artifacts reference generation output, and this selector owns no independent handle or cross-generation history.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Successful lookup pays native project-key/path/identity work before an own
+ *   record probe. A first miss materializes output keys, key/value pairs and the
+ *   identity index, paying every key's text and uncached native observations;
+ *   later misses reuse it. Error routes format diagnostic/unknown-value text;
+ *   missing output also traverses reachable config references, reads their
+ *   selection data and constructs the path-list message. Costs follow those
+ *   populations, paths and content, not only the number of output keys.
+ * @evidence contracts/performance.md#reuse-equivalent-work The output index is reused only for the same immutable generation and project root; text and maps remain coupled by the saved producer key, not by an inferred equality of their contents.
+ */
+export declare function selectTransformedSource(props: {
+    /** Absolute native module spelling whose producer output is requested. */
+    file: string;
+    /**
+     * Stable generation root used by project keys and alternate producer
+     * spellings.
+     */
+    projectRoot: string;
+    /** Immutable compiler generation supplying coupled text and map records. */
+    result: ITtscCompilerTransformation;
+    /** Selected config address used only when reporting missing program output. */
+    tsconfig: string;
+}): TtscTransformedOutput;

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

@@ -0,0 +1,75 @@
+'use strict';
+
+var searchedReferencedProjects = require('../../tsconfig/searchedReferencedProjects.js');
+var formatDiagnostics = require('../diagnostics/formatDiagnostics.js');
+var formatUnknownError = require('../diagnostics/formatUnknownError.js');
+var TtscCompileFailureError = require('../errors/TtscCompileFailureError.js');
+var TtscMissingProgramOutputError = require('../errors/TtscMissingProgramOutputError.js');
+var toProjectKey = require('../project/toProjectKey.js');
+var createEnvelopeKeyIndex = require('./createEnvelopeKeyIndex.js');
+var derivationIdentity = require('./derivationIdentity.js');
+var envelopeDerivation = require('./envelopeDerivation.js');
+
+/**
+ * Extract the transformed source for a single file from the compiler result,
+ * with the source map the envelope carries for the same key.
+ *
+ * Throws on compiler exception or hard failure so the bundler surfaces the
+ * error to the user. On success, tries a fast exact-match lookup by
+ * project-relative key first, then falls back to a lazy first-match identity
+ * index when the key in `result.typescript` uses an absolute or
+ * differently-cased path. The map is read under the key the text was found
+ * under, so the two always describe the same envelope entry
+ * (samchon/ttsc#1392).
+ *
+ * @evidence contracts/common.md#principled-implementation The matched producer key selects both transformed text and its own source map, preventing provenance from another alias entry; exception/failure results and missing program output raise their distinct supported errors.
+ * @evidence contracts/common.md#clear-and-simple-design Result discrimination precedes lookup, a local output adapter binds code to map, and the shared identity index isolates alternate-spelling lookup from error reporting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback supports real producer key spelling differences with first-match precedence; absent output is reported rather than synthesized from original source or a different module's map.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe source/map coupling, error behavior and exact versus identity lookup; the acknowledgment block follows the documentation skill's spacing guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Project key matching and alternate key identities use the envelope's filesystem context, so physical aliases and native case behavior are not guessed from lowercased strings.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One key per physical output identity is retained in weakly owned envelope state; returned artifacts reference generation output, and this selector owns no independent handle or cross-generation history.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Successful lookup pays native project-key/path/identity work before an own
+ *   record probe. A first miss materializes output keys, key/value pairs and the
+ *   identity index, paying every key's text and uncached native observations;
+ *   later misses reuse it. Error routes format diagnostic/unknown-value text;
+ *   missing output also traverses reachable config references, reads their
+ *   selection data and constructs the path-list message. Costs follow those
+ *   populations, paths and content, not only the number of output keys.
+ * @evidence contracts/performance.md#reuse-equivalent-work The output index is reused only for the same immutable generation and project root; text and maps remain coupled by the saved producer key, not by an inferred equality of their contents.
+ */
+function selectTransformedSource(props) {
+    if (props.result.type === "exception") {
+        throw new TtscCompileFailureError.TtscCompileFailureError(formatUnknownError.formatUnknownError(props.result.error));
+    }
+    if (props.result.type === "failure") {
+        throw new TtscCompileFailureError.TtscCompileFailureError(formatDiagnostics.formatDiagnostics(props.result.diagnostics));
+    }
+    // Fast path: the compiler key matches the normalised project-relative path.
+    const state = envelopeDerivation.envelopeDerivation(props);
+    const key = toProjectKey.toProjectKey(props.projectRoot, props.file, state.identityContext);
+    const { sourceMaps, typescript } = props.result;
+    const output = (found) => {
+        const map = sourceMaps !== undefined &&
+            Object.prototype.hasOwnProperty.call(sourceMaps, found)
+            ? sourceMaps[found]
+            : undefined;
+        return map === undefined
+            ? { code: typescript[found] }
+            : { code: typescript[found], map };
+    };
+    if (Object.prototype.hasOwnProperty.call(typescript, key)) {
+        return output(key);
+    }
+    // Slow path: the first-match identity index of the envelope's `typescript`
+    // keys, built once per generation instead of scanned per delivery.
+    const index = (state.outputIndex ??= createEnvelopeKeyIndex.createEnvelopeKeyIndex(state, props.projectRoot, Object.fromEntries(Object.keys(typescript).map((entry) => [entry, entry]))));
+    const found = index.get(derivationIdentity.derivationIdentity(state, props.file));
+    if (found !== undefined) {
+        return output(found);
+    }
+    throw new TtscMissingProgramOutputError.TtscMissingProgramOutputError(props.file, props.tsconfig, searchedReferencedProjects.searchedReferencedProjects(props.tsconfig));
+}
+
+exports.selectTransformedSource = selectTransformedSource;
+//# sourceMappingURL=selectTransformedSource.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectTransformedSource.js","sources":["../../../../src/core/transform/envelope/selectTransformedSource.ts"],"sourcesContent":[null],"names":["TtscCompileFailureError","formatUnknownError","formatDiagnostics","envelopeDerivation","toProjectKey","createEnvelopeKeyIndex","derivationIdentity","TtscMissingProgramOutputError","searchedReferencedProjects"],"mappings":";;;;;;;;;;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACG,SAAU,uBAAuB,CAAC,KAYvC,EAAA;IACC,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;AACrC,QAAA,MAAM,IAAIA,+CAAuB,CAACC,qCAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3E;IACA,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACnC,QAAA,MAAM,IAAID,+CAAuB,CAC/BE,mCAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAC5C;IACH;;AAGA,IAAA,MAAM,KAAK,GAAGC,qCAAkB,CAAC,KAAK,CAAC;AACvC,IAAA,MAAM,GAAG,GAAGC,yBAAY,CACtB,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,eAAe,CACtB;IACD,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC,MAAM;AAC/C,IAAA,MAAM,MAAM,GAAG,CAAC,KAAa,KAA2B;AACtD,QAAA,MAAM,GAAG,GACP,UAAU,KAAK,SAAS;YACxB,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK;AACpD,cAAE,UAAU,CAAC,KAAK;cAChB,SAAS;QACf,OAAO,GAAG,KAAK;cACX,EAAE,IAAI,EAAE,UAAU,CAAC,KAAK,CAAE;cAC1B,EAAE,IAAI,EAAE,UAAU,CAAC,KAAK,CAAE,EAAE,GAAG,EAAE;AACvC,IAAA,CAAC;AACD,IAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE;AACzD,QAAA,OAAO,MAAM,CAAC,GAAG,CAAC;IACpB;;;AAGA,IAAA,MAAM,KAAK,IAAI,KAAK,CAAC,WAAW,KAAKC,6CAAsB,CACzD,KAAK,EACL,KAAK,CAAC,WAAW,EACjB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAC3E,CAAC;AACF,IAAA,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAACC,qCAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;AAC9D,IAAA,IAAI,KAAK,KAAK,SAAS,EAAE;AACvB,QAAA,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB;AACA,IAAA,MAAM,IAAIC,2DAA6B,CACrC,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,QAAQ,EACdC,qDAA0B,CAAC,KAAK,CAAC,QAAQ,CAAC,CAC3C;AACH;;;;"}