@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/generation/TtscFailedGenerationValidation.d.cts

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState.cjs";
+/**
+ * Filesystem comparison baseline that may authorize replacing a terminal failed
+ * generation. The cached attempt supplies retained comparison data; its live
+ * watchers and clock probe are released before the terminal error is retained.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys, project hashes, walk failure shape and exact out-of-walk states jointly represent the environment whose change permits retry; cached supplies the same attempt's membership and identity context.
+ * @evidence contracts/common.md#clear-and-simple-design This carrier groups project-walk and external-input baselines without owning re-probing or cache lifecycle decisions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retry premises preserve observed state rather than substituting a module request count or arbitrary timeout for environmental change.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes retained comparison data from released live resources, and separated member comments identify each witness and undefined declared-scope meaning.
+ * @evidence contracts/portability.md#os-neutral-implementation Exact input-state keys retain native absolute paths, while declared project keys and project hashes use the captured compiler-key protocol; cached supplies the original native identity and membership context rather than reinterpreting either representation here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationValidation only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationValidation only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationValidation only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscFailedGenerationValidation {
+    /** Last attempted generation, retained only as a comparison baseline. */
+    cached: TtscCachedProjectTransform;
+    /** Input keys whose content can affect the generation, or the whole walk. */
+    declaredInputs: ReadonlySet<string> | undefined;
+    /** Fingerprints of every out-of-walk and exact host input. */
+    inputStates: ReadonlyMap<string, TtscFailedGenerationInputState>;
+    /** On-disk project hashes the final attempt's walk recorded. */
+    projectInputHashes: Readonly<Record<string, string>>;
+    /** Coherence and exact failure state of the final project walk. */
+    projectWalkComplete: boolean;
+    /**
+     * Fingerprint of the walk failures relevant to the declared inputs, so a
+     * change in them permits a retry.
+     */
+    projectWalkFailures: string;
+}

package/lib/core/transform/generation/TtscFailedGenerationValidation.d.mts

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState.mjs";
+/**
+ * Filesystem comparison baseline that may authorize replacing a terminal failed
+ * generation. The cached attempt supplies retained comparison data; its live
+ * watchers and clock probe are released before the terminal error is retained.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys, project hashes, walk failure shape and exact out-of-walk states jointly represent the environment whose change permits retry; cached supplies the same attempt's membership and identity context.
+ * @evidence contracts/common.md#clear-and-simple-design This carrier groups project-walk and external-input baselines without owning re-probing or cache lifecycle decisions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retry premises preserve observed state rather than substituting a module request count or arbitrary timeout for environmental change.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes retained comparison data from released live resources, and separated member comments identify each witness and undefined declared-scope meaning.
+ * @evidence contracts/portability.md#os-neutral-implementation Exact input-state keys retain native absolute paths, while declared project keys and project hashes use the captured compiler-key protocol; cached supplies the original native identity and membership context rather than reinterpreting either representation here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationValidation only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationValidation only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationValidation only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscFailedGenerationValidation {
+    /** Last attempted generation, retained only as a comparison baseline. */
+    cached: TtscCachedProjectTransform;
+    /** Input keys whose content can affect the generation, or the whole walk. */
+    declaredInputs: ReadonlySet<string> | undefined;
+    /** Fingerprints of every out-of-walk and exact host input. */
+    inputStates: ReadonlyMap<string, TtscFailedGenerationInputState>;
+    /** On-disk project hashes the final attempt's walk recorded. */
+    projectInputHashes: Readonly<Record<string, string>>;
+    /** Coherence and exact failure state of the final project walk. */
+    projectWalkComplete: boolean;
+    /**
+     * Fingerprint of the walk failures relevant to the declared inputs, so a
+     * change in them permits a retry.
+     */
+    projectWalkFailures: string;
+}

package/lib/core/transform/generation/TtscFailedGenerationValidation.d.ts

@@ -0,0 +1,39 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState";
+/**
+ * Filesystem comparison baseline that may authorize replacing a terminal failed
+ * generation. The cached attempt supplies retained comparison data; its live
+ * watchers and clock probe are released before the terminal error is retained.
+ *
+ * @evidence contracts/common.md#principled-implementation Declared keys, project hashes, walk failure shape and exact out-of-walk states jointly represent the environment whose change permits retry; cached supplies the same attempt's membership and identity context.
+ * @evidence contracts/common.md#clear-and-simple-design This carrier groups project-walk and external-input baselines without owning re-probing or cache lifecycle decisions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Retry premises preserve observed state rather than substituting a module request count or arbitrary timeout for environmental change.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes retained comparison data from released live resources, and separated member comments identify each witness and undefined declared-scope meaning.
+ * @evidence contracts/portability.md#os-neutral-implementation Exact input-state keys retain native absolute paths, while declared project keys and project hashes use the captured compiler-key protocol; cached supplies the original native identity and membership context rather than reinterpreting either representation here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationValidation only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationValidation only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationValidation only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscFailedGenerationValidation {
+    /** Last attempted generation, retained only as a comparison baseline. */
+    cached: TtscCachedProjectTransform;
+    /** Input keys whose content can affect the generation, or the whole walk. */
+    declaredInputs: ReadonlySet<string> | undefined;
+    /** Fingerprints of every out-of-walk and exact host input. */
+    inputStates: ReadonlyMap<string, TtscFailedGenerationInputState>;
+    /** On-disk project hashes the final attempt's walk recorded. */
+    projectInputHashes: Readonly<Record<string, string>>;
+    /** Coherence and exact failure state of the final project walk. */
+    projectWalkComplete: boolean;
+    /**
+     * Fingerprint of the walk failures relevant to the declared inputs, so a
+     * change in them permits a retry.
+     */
+    projectWalkFailures: string;
+}

package/lib/core/transform/generation/TtscGenerationProofFailure.d.cts

@@ -0,0 +1,34 @@
+/**
+ * One failed proof that prevents a whole-project transform becoming reusable.
+ * Domain identifies the evidence family, while kind remains open to that
+ * producer's failure classes and optional path/detail supply diagnostic
+ * context.
+ *
+ * @evidence contracts/common.md#principled-implementation The closed evidence-family union distinguishes project, graph, host and external failures; an open kind preserves producer-specific causes without conflating them with domain.
+ * @evidence contracts/common.md#clear-and-simple-design One witness carries classification and optional attribution; bounded aggregation and rendering remain separate responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Witnesses report actual producer failures rather than expected test results or a boolean that hides which proof was absent.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains classification and optional context, and separated members document lexical path representation and producer detail.
+ * @evidence contracts/portability.md#os-neutral-implementation Optional path carries the producer's absolute native lexical spelling; the diagnostic renderer owns native containment and display conversion, without treating this field as a portable identity key.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailure only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailure only declares a shape; it has no work to reuse
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailure {
+    /**
+     * Which evidence family failed: the project walk, out-of-walk inputs, the
+     * compiler graph, or host inputs.
+     */
+    domain: "external" | "graph" | "host" | "project";
+    /** Machine-readable failure class printed verbatim in terminal diagnostics. */
+    kind: string;
+    /** Optional producer detail, such as the native compiler observation failure. */
+    detail?: string;
+    /** Absolute lexical spelling of the input or directory that failed proof. */
+    path?: string;
+}

package/lib/core/transform/generation/TtscGenerationProofFailure.d.mts

@@ -0,0 +1,34 @@
+/**
+ * One failed proof that prevents a whole-project transform becoming reusable.
+ * Domain identifies the evidence family, while kind remains open to that
+ * producer's failure classes and optional path/detail supply diagnostic
+ * context.
+ *
+ * @evidence contracts/common.md#principled-implementation The closed evidence-family union distinguishes project, graph, host and external failures; an open kind preserves producer-specific causes without conflating them with domain.
+ * @evidence contracts/common.md#clear-and-simple-design One witness carries classification and optional attribution; bounded aggregation and rendering remain separate responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Witnesses report actual producer failures rather than expected test results or a boolean that hides which proof was absent.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains classification and optional context, and separated members document lexical path representation and producer detail.
+ * @evidence contracts/portability.md#os-neutral-implementation Optional path carries the producer's absolute native lexical spelling; the diagnostic renderer owns native containment and display conversion, without treating this field as a portable identity key.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailure only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailure only declares a shape; it has no work to reuse
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailure {
+    /**
+     * Which evidence family failed: the project walk, out-of-walk inputs, the
+     * compiler graph, or host inputs.
+     */
+    domain: "external" | "graph" | "host" | "project";
+    /** Machine-readable failure class printed verbatim in terminal diagnostics. */
+    kind: string;
+    /** Optional producer detail, such as the native compiler observation failure. */
+    detail?: string;
+    /** Absolute lexical spelling of the input or directory that failed proof. */
+    path?: string;
+}

package/lib/core/transform/generation/TtscGenerationProofFailure.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One failed proof that prevents a whole-project transform becoming reusable.
+ * Domain identifies the evidence family, while kind remains open to that
+ * producer's failure classes and optional path/detail supply diagnostic
+ * context.
+ *
+ * @evidence contracts/common.md#principled-implementation The closed evidence-family union distinguishes project, graph, host and external failures; an open kind preserves producer-specific causes without conflating them with domain.
+ * @evidence contracts/common.md#clear-and-simple-design One witness carries classification and optional attribution; bounded aggregation and rendering remain separate responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Witnesses report actual producer failures rather than expected test results or a boolean that hides which proof was absent.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains classification and optional context, and separated members document lexical path representation and producer detail.
+ * @evidence contracts/portability.md#os-neutral-implementation Optional path carries the producer's absolute native lexical spelling; the diagnostic renderer owns native containment and display conversion, without treating this field as a portable identity key.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailure only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailure only declares a shape; it has no work to reuse
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailure only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailure {
+    /**
+     * Which evidence family failed: the project walk, out-of-walk inputs, the
+     * compiler graph, or host inputs.
+     */
+    domain: "external" | "graph" | "host" | "project";
+    /** Machine-readable failure class printed verbatim in terminal diagnostics. */
+    kind: string;
+    /** Optional producer detail, such as the native compiler observation failure. */
+    detail?: string;
+    /** Absolute lexical spelling of the input or directory that failed proof. */
+    path?: string;
+}

package/lib/core/transform/generation/TtscGenerationProofFailures.d.cts

@@ -0,0 +1,32 @@
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.cjs";
+/**
+ * Bounded proof witnesses for one transform attempt, populated through
+ * recordGenerationProofFailure. The seen set covers retained entries only;
+ * omitted is a saturated count of additional occurrences, not a unique count.
+ *
+ * @evidence contracts/common.md#principled-implementation Entries preserve printable witnesses, seen identifies retained duplicates and omitted records loss without retaining an unbounded identity set.
+ * @evidence contracts/common.md#clear-and-simple-design The carrier separates retained evidence from dropped occurrence accounting; the shared recorder enforces its bound and consistency.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Lost evidence remains visible through omitted rather than being silently discarded or claimed deduplicated without a retained identity.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states recorder ownership and duplicate-count limitations, while separated member comments explain each representation.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries preserve each witness's native lexical path unchanged; seen stores opaque recorder identities rather than interpreting path separators or filesystem equivalence.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailures only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailures only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailures only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailures {
+    /** Unique witnesses kept, at most `MAX_GENERATION_PROOF_FAILURES`. */
+    entries: TtscGenerationProofFailure[];
+    /** Saturated count of further witness occurrences dropped after the bound. */
+    omitted: number;
+    /**
+     * Keys of the kept witnesses, bounded with them so duplicates are not
+     * recorded twice.
+     */
+    seen: Set<string>;
+}

package/lib/core/transform/generation/TtscGenerationProofFailures.d.mts

@@ -0,0 +1,32 @@
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure.mjs";
+/**
+ * Bounded proof witnesses for one transform attempt, populated through
+ * recordGenerationProofFailure. The seen set covers retained entries only;
+ * omitted is a saturated count of additional occurrences, not a unique count.
+ *
+ * @evidence contracts/common.md#principled-implementation Entries preserve printable witnesses, seen identifies retained duplicates and omitted records loss without retaining an unbounded identity set.
+ * @evidence contracts/common.md#clear-and-simple-design The carrier separates retained evidence from dropped occurrence accounting; the shared recorder enforces its bound and consistency.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Lost evidence remains visible through omitted rather than being silently discarded or claimed deduplicated without a retained identity.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states recorder ownership and duplicate-count limitations, while separated member comments explain each representation.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries preserve each witness's native lexical path unchanged; seen stores opaque recorder identities rather than interpreting path separators or filesystem equivalence.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailures only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailures only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailures only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailures {
+    /** Unique witnesses kept, at most `MAX_GENERATION_PROOF_FAILURES`. */
+    entries: TtscGenerationProofFailure[];
+    /** Saturated count of further witness occurrences dropped after the bound. */
+    omitted: number;
+    /**
+     * Keys of the kept witnesses, bounded with them so duplicates are not
+     * recorded twice.
+     */
+    seen: Set<string>;
+}

package/lib/core/transform/generation/TtscGenerationProofFailures.d.ts

@@ -0,0 +1,32 @@
+import type { TtscGenerationProofFailure } from "./TtscGenerationProofFailure";
+/**
+ * Bounded proof witnesses for one transform attempt, populated through
+ * recordGenerationProofFailure. The seen set covers retained entries only;
+ * omitted is a saturated count of additional occurrences, not a unique count.
+ *
+ * @evidence contracts/common.md#principled-implementation Entries preserve printable witnesses, seen identifies retained duplicates and omitted records loss without retaining an unbounded identity set.
+ * @evidence contracts/common.md#clear-and-simple-design The carrier separates retained evidence from dropped occurrence accounting; the shared recorder enforces its bound and consistency.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Lost evidence remains visible through omitted rather than being silently discarded or claimed deduplicated without a retained identity.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states recorder ownership and duplicate-count limitations, while separated member comments explain each representation.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries preserve each witness's native lexical path unchanged; seen stores opaque recorder identities rather than interpreting path separators or filesystem equivalence.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscGenerationProofFailures only declares a shape; it has no computation
+ *   at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscGenerationProofFailures only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscGenerationProofFailures only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export interface TtscGenerationProofFailures {
+    /** Unique witnesses kept, at most `MAX_GENERATION_PROOF_FAILURES`. */
+    entries: TtscGenerationProofFailure[];
+    /** Saturated count of further witness occurrences dropped after the bound. */
+    omitted: number;
+    /**
+     * Keys of the kept witnesses, bounded with them so duplicates are not
+     * recorded twice.
+     */
+    seen: Set<string>;
+}

package/lib/core/transform/generation/captureFailedGenerationInputStates.d.cts

@@ -0,0 +1,26 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState.cjs";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/**
+ * Snapshot the recorded external paths, persistent host paths, attributed
+ * failure paths and plugin source roots for terminal retry comparison
+ * (`pluginSourceState`, samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * Ordinary-path signatures are observed before full state and retained only
+ * when the filesystem clock proves separation. Plugin trees carry no single
+ * path signature because their source/build environment requires whole-tree
+ * validation. The returned map belongs to the terminal comparison baseline. The
+ * async generation owner already attempted native environment preparation;
+ * unavailable authority records a missing tree state without a cold fallback.
+ * Standalone synchronous results retain their original native capture API.
+ *
+ * @evidence contracts/common.md#principled-implementation External paths, surviving host paths, attributed failures and plugin source roots form the retry environment; metadata-before-state observation prevents a concurrent read from authorizing unchanged-state reuse incorrectly.
+ * @evidence contracts/common.md#clear-and-simple-design This capture constructs one baseline map, delegating persistence selection, metadata evidence and ordinary/tree state composition to their owning helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host-path selection excludes adapter-owned scratch/wrapper artifacts rather than unrelated dependencies; attributed failure paths are separately retained and do not receive that filter. Missing plugin state stays a missing marker, not a parent-metadata tree proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish ordinary signature timing, plugin-tree validation and transferred baseline ownership, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve normalizes observed spellings and resultFilesystem supplies filesystem capabilities; plugin source state uses the shared native Go/build environment boundary.
+ * @evidence contracts/performance.md#efficient-algorithms External/host/failure populations incur native resolve/text/Set work before the unique union is copied and sorted. Host selection and cold plugin selection retain their full scan/identity costs. Each unique tree delegates source/build state work; each ordinary path observes metadata before a fingerprint that may reread metadata, bytes, realpath and directory entries. Cost includes spellings, payload bytes and subtree population; temporary arrays/sets/map records grow with union size.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact spelling union avoids duplicating whole fingerprint capture, while physically equivalent aliases remain distinct observations. Shared envelope/plugin owners retain their validity rules; recorded separable signatures permit later metadata-first comparison but do not reuse current metadata collection or certify an unreadable tree.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One map of distinct recorded inputs and state/signature text transfers to terminal validation; input count and spelling bytes have no cap here. No observer or scratch directory is acquired, and terminal/cache ownership controls baseline lifetime. Native plugin reading retention belongs to its separate environment owner.
+ */
+export declare function captureFailedGenerationInputStates(cached: TtscCachedProjectTransform, failures: TtscGenerationProofFailures): ReadonlyMap<string, TtscFailedGenerationInputState>;

package/lib/core/transform/generation/captureFailedGenerationInputStates.d.mts

@@ -0,0 +1,26 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState.mjs";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.mjs";
+/**
+ * Snapshot the recorded external paths, persistent host paths, attributed
+ * failure paths and plugin source roots for terminal retry comparison
+ * (`pluginSourceState`, samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * Ordinary-path signatures are observed before full state and retained only
+ * when the filesystem clock proves separation. Plugin trees carry no single
+ * path signature because their source/build environment requires whole-tree
+ * validation. The returned map belongs to the terminal comparison baseline. The
+ * async generation owner already attempted native environment preparation;
+ * unavailable authority records a missing tree state without a cold fallback.
+ * Standalone synchronous results retain their original native capture API.
+ *
+ * @evidence contracts/common.md#principled-implementation External paths, surviving host paths, attributed failures and plugin source roots form the retry environment; metadata-before-state observation prevents a concurrent read from authorizing unchanged-state reuse incorrectly.
+ * @evidence contracts/common.md#clear-and-simple-design This capture constructs one baseline map, delegating persistence selection, metadata evidence and ordinary/tree state composition to their owning helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host-path selection excludes adapter-owned scratch/wrapper artifacts rather than unrelated dependencies; attributed failure paths are separately retained and do not receive that filter. Missing plugin state stays a missing marker, not a parent-metadata tree proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish ordinary signature timing, plugin-tree validation and transferred baseline ownership, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve normalizes observed spellings and resultFilesystem supplies filesystem capabilities; plugin source state uses the shared native Go/build environment boundary.
+ * @evidence contracts/performance.md#efficient-algorithms External/host/failure populations incur native resolve/text/Set work before the unique union is copied and sorted. Host selection and cold plugin selection retain their full scan/identity costs. Each unique tree delegates source/build state work; each ordinary path observes metadata before a fingerprint that may reread metadata, bytes, realpath and directory entries. Cost includes spellings, payload bytes and subtree population; temporary arrays/sets/map records grow with union size.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact spelling union avoids duplicating whole fingerprint capture, while physically equivalent aliases remain distinct observations. Shared envelope/plugin owners retain their validity rules; recorded separable signatures permit later metadata-first comparison but do not reuse current metadata collection or certify an unreadable tree.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One map of distinct recorded inputs and state/signature text transfers to terminal validation; input count and spelling bytes have no cap here. No observer or scratch directory is acquired, and terminal/cache ownership controls baseline lifetime. Native plugin reading retention belongs to its separate environment owner.
+ */
+export declare function captureFailedGenerationInputStates(cached: TtscCachedProjectTransform, failures: TtscGenerationProofFailures): ReadonlyMap<string, TtscFailedGenerationInputState>;

package/lib/core/transform/generation/captureFailedGenerationInputStates.d.ts

@@ -0,0 +1,26 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscFailedGenerationInputState } from "./TtscFailedGenerationInputState";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+/**
+ * Snapshot the recorded external paths, persistent host paths, attributed
+ * failure paths and plugin source roots for terminal retry comparison
+ * (`pluginSourceState`, samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * Ordinary-path signatures are observed before full state and retained only
+ * when the filesystem clock proves separation. Plugin trees carry no single
+ * path signature because their source/build environment requires whole-tree
+ * validation. The returned map belongs to the terminal comparison baseline. The
+ * async generation owner already attempted native environment preparation;
+ * unavailable authority records a missing tree state without a cold fallback.
+ * Standalone synchronous results retain their original native capture API.
+ *
+ * @evidence contracts/common.md#principled-implementation External paths, surviving host paths, attributed failures and plugin source roots form the retry environment; metadata-before-state observation prevents a concurrent read from authorizing unchanged-state reuse incorrectly.
+ * @evidence contracts/common.md#clear-and-simple-design This capture constructs one baseline map, delegating persistence selection, metadata evidence and ordinary/tree state composition to their owning helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host-path selection excludes adapter-owned scratch/wrapper artifacts rather than unrelated dependencies; attributed failure paths are separately retained and do not receive that filter. Missing plugin state stays a missing marker, not a parent-metadata tree proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish ordinary signature timing, plugin-tree validation and transferred baseline ownership, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve normalizes observed spellings and resultFilesystem supplies filesystem capabilities; plugin source state uses the shared native Go/build environment boundary.
+ * @evidence contracts/performance.md#efficient-algorithms External/host/failure populations incur native resolve/text/Set work before the unique union is copied and sorted. Host selection and cold plugin selection retain their full scan/identity costs. Each unique tree delegates source/build state work; each ordinary path observes metadata before a fingerprint that may reread metadata, bytes, realpath and directory entries. Cost includes spellings, payload bytes and subtree population; temporary arrays/sets/map records grow with union size.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact spelling union avoids duplicating whole fingerprint capture, while physically equivalent aliases remain distinct observations. Shared envelope/plugin owners retain their validity rules; recorded separable signatures permit later metadata-first comparison but do not reuse current metadata collection or certify an unreadable tree.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One map of distinct recorded inputs and state/signature text transfers to terminal validation; input count and spelling bytes have no cap here. No observer or scratch directory is acquired, and terminal/cache ownership controls baseline lifetime. Native plugin reading retention belongs to its separate environment owner.
+ */
+export declare function captureFailedGenerationInputStates(cached: TtscCachedProjectTransform, failures: TtscGenerationProofFailures): ReadonlyMap<string, TtscFailedGenerationInputState>;

package/lib/core/transform/generation/captureFailedGenerationInputStates.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var path = require('node:path');
+var pluginSource = require('ttsc/plugin-source');
+var resultFilesystem = require('../cache/resultFilesystem.js');
+var selectPluginSourceInputs = require('../envelope/selectPluginSourceInputs.js');
+var inputMetadataEvidence = require('../inputs/inputMetadataEvidence.js');
+var pluginSourceState = require('../inputs/pluginSourceState.js');
+var preparePluginBuildEnvironments = require('../inputs/preparePluginBuildEnvironments.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+var failedGenerationInputState = require('./failedGenerationInputState.js');
+var selectPersistentHostInputs = require('./selectPersistentHostInputs.js');
+
+/**
+ * Snapshot the recorded external paths, persistent host paths, attributed
+ * failure paths and plugin source roots for terminal retry comparison
+ * (`pluginSourceState`, samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * Ordinary-path signatures are observed before full state and retained only
+ * when the filesystem clock proves separation. Plugin trees carry no single
+ * path signature because their source/build environment requires whole-tree
+ * validation. The returned map belongs to the terminal comparison baseline. The
+ * async generation owner already attempted native environment preparation;
+ * unavailable authority records a missing tree state without a cold fallback.
+ * Standalone synchronous results retain their original native capture API.
+ *
+ * @evidence contracts/common.md#principled-implementation External paths, surviving host paths, attributed failures and plugin source roots form the retry environment; metadata-before-state observation prevents a concurrent read from authorizing unchanged-state reuse incorrectly.
+ * @evidence contracts/common.md#clear-and-simple-design This capture constructs one baseline map, delegating persistence selection, metadata evidence and ordinary/tree state composition to their owning helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host-path selection excludes adapter-owned scratch/wrapper artifacts rather than unrelated dependencies; attributed failure paths are separately retained and do not receive that filter. Missing plugin state stays a missing marker, not a parent-metadata tree proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish ordinary signature timing, plugin-tree validation and transferred baseline ownership, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve normalizes observed spellings and resultFilesystem supplies filesystem capabilities; plugin source state uses the shared native Go/build environment boundary.
+ * @evidence contracts/performance.md#efficient-algorithms External/host/failure populations incur native resolve/text/Set work before the unique union is copied and sorted. Host selection and cold plugin selection retain their full scan/identity costs. Each unique tree delegates source/build state work; each ordinary path observes metadata before a fingerprint that may reread metadata, bytes, realpath and directory entries. Cost includes spellings, payload bytes and subtree population; temporary arrays/sets/map records grow with union size.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact spelling union avoids duplicating whole fingerprint capture, while physically equivalent aliases remain distinct observations. Shared envelope/plugin owners retain their validity rules; recorded separable signatures permit later metadata-first comparison but do not reuse current metadata collection or certify an unreadable tree.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One map of distinct recorded inputs and state/signature text transfers to terminal validation; input count and spelling bytes have no cap here. No observer or scratch directory is acquired, and terminal/cache ownership controls baseline lifetime. Native plugin reading retention belongs to its separate environment owner.
+ */
+function captureFailedGenerationInputStates(cached, failures) {
+    const filesystem = resultFilesystem.resultFilesystem(cached.result);
+    const inputs = new Set((cached.externalInputPaths ?? []).map((input) => path.resolve(input)));
+    for (const input of selectPersistentHostInputs.selectPersistentHostInputs({
+        filesystem,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
+        temporaryTsconfig: cached.temporaryTsconfig,
+    })) {
+        inputs.add(path.resolve(input));
+    }
+    for (const failure of failures.entries) {
+        if (failure.path !== undefined)
+            inputs.add(path.resolve(failure.path));
+    }
+    const trees = selectPluginSourceInputs.selectPluginSourceInputs(cached.result);
+    return new Map([...new Set([...inputs, ...trees.keys()])].sort().map((input) => {
+        if (trees.has(input)) {
+            return [
+                input,
+                {
+                    state: pluginSourceState.pluginSourceState(input, preparePluginBuildEnvironments.usesPreparedPluginBuildEnvironments(cached.result)
+                        ? {
+                            environment: pluginSource.PluginBuildEnvironmentReadings.cached(input),
+                        }
+                        : undefined) ?? MISSING_INPUT_STATE.MISSING_INPUT_STATE,
+                    tree: true,
+                },
+            ];
+        }
+        // Observed before the state is read, so a write during the read makes
+        // the recorded signature disagree with the next observation.
+        const evidence = inputMetadataEvidence.inputMetadataEvidence(input, filesystem);
+        return [
+            input,
+            {
+                ...(evidence?.separable === true
+                    ? { signature: evidence.signature }
+                    : {}),
+                state: failedGenerationInputState.failedGenerationInputState(input, filesystem),
+            },
+        ];
+    }));
+}
+
+exports.captureFailedGenerationInputStates = captureFailedGenerationInputStates;
+//# sourceMappingURL=captureFailedGenerationInputStates.js.map

package/lib/core/transform/generation/captureFailedGenerationInputStates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureFailedGenerationInputStates.js","sources":["../../../../src/core/transform/generation/captureFailedGenerationInputStates.ts"],"sourcesContent":[null],"names":["resultFilesystem","selectPersistentHostInputs","selectPluginSourceInputs","pluginSourceState","usesPreparedPluginBuildEnvironments","PluginBuildEnvironmentReadings","MISSING_INPUT_STATE","inputMetadataEvidence","failedGenerationInputState"],"mappings":";;;;;;;;;;;;;AAeA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,kCAAkC,CAChD,MAAkC,EAClC,QAAqC,EAAA;IAErC,MAAM,UAAU,GAAGA,iCAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;AAClD,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CACtE;AACD,IAAA,KAAK,MAAM,KAAK,IAAIC,qDAA0B,CAAC;QAC7C,UAAU;QACV,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;AAC5C,KAAA,CAAC,EAAE;QACF,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC;AACA,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,OAAO,EAAE;AACtC,QAAA,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE;IACA,MAAM,KAAK,GAAGC,iDAAwB,CAAC,MAAM,CAAC,MAAM,CAAC;AACrD,IAAA,OAAO,IAAI,GAAG,CACZ,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,KAAI;AAC9D,QAAA,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACpB,OAAO;gBACL,KAAK;AACL,gBAAA;oBACE,KAAK,EACHC,mCAAiB,CACf,KAAK,EACLC,kEAAmC,CAAC,MAAM,CAAC,MAAM;AAC/C,0BAAE;AACE,4BAAA,WAAW,EAAEC,2CAA8B,CAAC,MAAM,CAAC,KAAK,CAAC;AAC1D;AACH,0BAAE,SAAS,CACd,IAAIC,uCAAmB;AAC1B,oBAAA,IAAI,EAAE,IAAI;AACX,iBAAA;aACF;QACH;;;QAGA,MAAM,QAAQ,GAAGC,2CAAqB,CAAC,KAAK,EAAE,UAAU,CAAC;QACzD,OAAO;YACL,KAAK;AACL,YAAA;AACE,gBAAA,IAAI,QAAQ,EAAE,SAAS,KAAK;AAC1B,sBAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS;sBAC/B,EAAE,CAAC;AACP,gBAAA,KAAK,EAAEC,qDAA0B,CAAC,KAAK,EAAE,UAAU,CAAC;AACrD,aAAA;SACF;IACH,CAAC,CAAC,CACH;AACH;;;;"}

package/lib/core/transform/generation/captureFailedGenerationInputStates.mjs

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { PluginBuildEnvironmentReadings } from 'ttsc/plugin-source';
+import { resultFilesystem } from '../cache/resultFilesystem.mjs';
+import { selectPluginSourceInputs } from '../envelope/selectPluginSourceInputs.mjs';
+import { inputMetadataEvidence } from '../inputs/inputMetadataEvidence.mjs';
+import { pluginSourceState } from '../inputs/pluginSourceState.mjs';
+import { usesPreparedPluginBuildEnvironments } from '../inputs/preparePluginBuildEnvironments.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+import { failedGenerationInputState } from './failedGenerationInputState.mjs';
+import { selectPersistentHostInputs } from './selectPersistentHostInputs.mjs';
+
+/**
+ * Snapshot the recorded external paths, persistent host paths, attributed
+ * failure paths and plugin source roots for terminal retry comparison
+ * (`pluginSourceState`, samchon/ttsc#1487, samchon/ttsc#1493).
+ *
+ * Ordinary-path signatures are observed before full state and retained only
+ * when the filesystem clock proves separation. Plugin trees carry no single
+ * path signature because their source/build environment requires whole-tree
+ * validation. The returned map belongs to the terminal comparison baseline. The
+ * async generation owner already attempted native environment preparation;
+ * unavailable authority records a missing tree state without a cold fallback.
+ * Standalone synchronous results retain their original native capture API.
+ *
+ * @evidence contracts/common.md#principled-implementation External paths, surviving host paths, attributed failures and plugin source roots form the retry environment; metadata-before-state observation prevents a concurrent read from authorizing unchanged-state reuse incorrectly.
+ * @evidence contracts/common.md#clear-and-simple-design This capture constructs one baseline map, delegating persistence selection, metadata evidence and ordinary/tree state composition to their owning helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host-path selection excludes adapter-owned scratch/wrapper artifacts rather than unrelated dependencies; attributed failure paths are separately retained and do not receive that filter. Missing plugin state stays a missing marker, not a parent-metadata tree proof.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish ordinary signature timing, plugin-tree validation and transferred baseline ownership, with separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve normalizes observed spellings and resultFilesystem supplies filesystem capabilities; plugin source state uses the shared native Go/build environment boundary.
+ * @evidence contracts/performance.md#efficient-algorithms External/host/failure populations incur native resolve/text/Set work before the unique union is copied and sorted. Host selection and cold plugin selection retain their full scan/identity costs. Each unique tree delegates source/build state work; each ordinary path observes metadata before a fingerprint that may reread metadata, bytes, realpath and directory entries. Cost includes spellings, payload bytes and subtree population; temporary arrays/sets/map records grow with union size.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact spelling union avoids duplicating whole fingerprint capture, while physically equivalent aliases remain distinct observations. Shared envelope/plugin owners retain their validity rules; recorded separable signatures permit later metadata-first comparison but do not reuse current metadata collection or certify an unreadable tree.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One map of distinct recorded inputs and state/signature text transfers to terminal validation; input count and spelling bytes have no cap here. No observer or scratch directory is acquired, and terminal/cache ownership controls baseline lifetime. Native plugin reading retention belongs to its separate environment owner.
+ */
+function captureFailedGenerationInputStates(cached, failures) {
+    const filesystem = resultFilesystem(cached.result);
+    const inputs = new Set((cached.externalInputPaths ?? []).map((input) => path.resolve(input)));
+    for (const input of selectPersistentHostInputs({
+        filesystem,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
+        temporaryTsconfig: cached.temporaryTsconfig,
+    })) {
+        inputs.add(path.resolve(input));
+    }
+    for (const failure of failures.entries) {
+        if (failure.path !== undefined)
+            inputs.add(path.resolve(failure.path));
+    }
+    const trees = selectPluginSourceInputs(cached.result);
+    return new Map([...new Set([...inputs, ...trees.keys()])].sort().map((input) => {
+        if (trees.has(input)) {
+            return [
+                input,
+                {
+                    state: pluginSourceState(input, usesPreparedPluginBuildEnvironments(cached.result)
+                        ? {
+                            environment: PluginBuildEnvironmentReadings.cached(input),
+                        }
+                        : undefined) ?? MISSING_INPUT_STATE,
+                    tree: true,
+                },
+            ];
+        }
+        // Observed before the state is read, so a write during the read makes
+        // the recorded signature disagree with the next observation.
+        const evidence = inputMetadataEvidence(input, filesystem);
+        return [
+            input,
+            {
+                ...(evidence?.separable === true
+                    ? { signature: evidence.signature }
+                    : {}),
+                state: failedGenerationInputState(input, filesystem),
+            },
+        ];
+    }));
+}
+
+export { captureFailedGenerationInputStates };
+//# sourceMappingURL=captureFailedGenerationInputStates.mjs.map

package/lib/core/transform/generation/captureFailedGenerationInputStates.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureFailedGenerationInputStates.mjs","sources":["../../../../src/core/transform/generation/captureFailedGenerationInputStates.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;AAeA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG,SAAU,kCAAkC,CAChD,MAAkC,EAClC,QAAqC,EAAA;IAErC,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;AAClD,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CACtE;AACD,IAAA,KAAK,MAAM,KAAK,IAAI,0BAA0B,CAAC;QAC7C,UAAU;QACV,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;AAC5C,KAAA,CAAC,EAAE;QACF,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC;AACA,IAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,OAAO,EAAE;AACtC,QAAA,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE;IACA,MAAM,KAAK,GAAG,wBAAwB,CAAC,MAAM,CAAC,MAAM,CAAC;AACrD,IAAA,OAAO,IAAI,GAAG,CACZ,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,KAAI;AAC9D,QAAA,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACpB,OAAO;gBACL,KAAK;AACL,gBAAA;oBACE,KAAK,EACH,iBAAiB,CACf,KAAK,EACL,mCAAmC,CAAC,MAAM,CAAC,MAAM;AAC/C,0BAAE;AACE,4BAAA,WAAW,EAAE,8BAA8B,CAAC,MAAM,CAAC,KAAK,CAAC;AAC1D;AACH,0BAAE,SAAS,CACd,IAAI,mBAAmB;AAC1B,oBAAA,IAAI,EAAE,IAAI;AACX,iBAAA;aACF;QACH;;;QAGA,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,UAAU,CAAC;QACzD,OAAO;YACL,KAAK;AACL,YAAA;AACE,gBAAA,IAAI,QAAQ,EAAE,SAAS,KAAK;AAC1B,sBAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS;sBAC/B,EAAE,CAAC;AACP,gBAAA,KAAK,EAAE,0BAA0B,CAAC,KAAK,EAAE,UAAU,CAAC;AACrD,aAAA;SACF;IACH,CAAC,CAAC,CACH;AACH;;;;"}