@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/solution-tests/attachments.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Attachment reads for the Solution Tests view. The expected/actual outputs and
+ * evaluator results are stored as File-field attachments on the `UiPathST*`
+ * records, so they aren't part of the reactive collections — we download them
+ * on demand through the `@uipath/uipath-typescript` Entities service, using the
+ * authenticated client vs-core exposes at `solution.api.sdk.core` (no consumer
+ * injection needed).
+ */
+import type { useSolution } from "@uipath/vs-core";
+type Solution = ReturnType<typeof useSolution>;
+/**
+ * Download an entity File-field attachment and parse it as JSON (falling back
+ * to raw text). `entityId` is the DataFabric entity id (GUID), not its name.
+ * Returns null when there's no active solution.
+ */
+export declare function fetchAttachment(solution: Solution, entityId: string, recordId: string, field: string, scope?: {
+    folderKey?: string;
+}): Promise<unknown>;
+export {};

package/dist/registry/solution-tests/attachments.js

@@ -0,0 +1,16 @@
+"use client";
+import { Entities } from "@uipath/uipath-typescript/entities";
+async function fetchAttachment(solution, entityId, recordId, field, scope) {
+    if (!solution) return null;
+    const entities = new Entities(solution.api.sdk.core);
+    const blob = await entities.downloadAttachment({
+        id: entityId
+    }, recordId, field, scope);
+    const text = await blob.text();
+    try {
+        return JSON.parse(text);
+    } catch  {
+        return text;
+    }
+}
+export { fetchAttachment };

package/dist/registry/solution-tests/baseline-compare.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export interface BaselineCompareRow {
+    label: string;
+    baseline: string | null;
+    current: string | null;
+    mono?: boolean;
+    /** Rendered after the new-run value to flag a change, e.g. a
+     *  VersionDeltaGlyph or a "Changed" badge. */
+    marker?: ReactNode;
+}
+export declare const BaselineCompare: ({ rows }: {
+    rows: BaselineCompareRow[];
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/registry/solution-tests/baseline-compare.js

@@ -0,0 +1,70 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { cn } from "../../lib/utils.js";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "../table/table.js";
+import { EMPTY_VALUE } from "./constants.js";
+const BaselineCompare = ({ rows })=>{
+    const { t } = useVertexTranslation();
+    const visible = rows.filter((row)=>null != row.baseline || null != row.current);
+    if (0 === visible.length) return null;
+    return /*#__PURE__*/ jsx("div", {
+        className: "w-fit max-w-full rounded-md border bg-muted/30",
+        children: /*#__PURE__*/ jsxs(Table, {
+            className: "w-auto text-xs",
+            children: [
+                /*#__PURE__*/ jsx(TableHeader, {
+                    children: /*#__PURE__*/ jsxs(TableRow, {
+                        className: "hover:bg-transparent",
+                        children: [
+                            /*#__PURE__*/ jsx(TableHead, {
+                                className: "h-8 px-3"
+                            }),
+                            /*#__PURE__*/ jsx(TableHead, {
+                                className: "h-8 px-3 text-xs",
+                                children: t("compare_baseline")
+                            }),
+                            /*#__PURE__*/ jsx(TableHead, {
+                                className: "h-8 px-3 text-xs",
+                                children: t("compare_new_run")
+                            })
+                        ]
+                    })
+                }),
+                /*#__PURE__*/ jsx(TableBody, {
+                    children: visible.map((row)=>/*#__PURE__*/ jsx(CompareRow, {
+                            row: row
+                        }, row.label))
+                })
+            ]
+        })
+    });
+};
+const CompareRow = ({ row })=>{
+    const valueClass = cn("px-3 py-1.5 whitespace-normal [overflow-wrap:anywhere] text-foreground", row.mono && "font-mono");
+    return /*#__PURE__*/ jsxs(TableRow, {
+        className: "hover:bg-transparent",
+        children: [
+            /*#__PURE__*/ jsx(TableHead, {
+                scope: "row",
+                className: "h-auto px-3 py-1.5 text-xs font-medium text-muted-foreground",
+                children: row.label
+            }),
+            /*#__PURE__*/ jsx(TableCell, {
+                className: valueClass,
+                children: row.baseline ?? EMPTY_VALUE
+            }),
+            /*#__PURE__*/ jsx(TableCell, {
+                className: valueClass,
+                children: /*#__PURE__*/ jsxs("span", {
+                    className: "inline-flex flex-wrap items-center gap-1",
+                    children: [
+                        row.current ?? EMPTY_VALUE,
+                        row.marker
+                    ]
+                })
+            })
+        ]
+    });
+};
+export { BaselineCompare };

package/dist/registry/solution-tests/config-version.d.ts

@@ -0,0 +1,5 @@
+import type { SolutionTestRun } from "./types";
+/** A run's configuration version, flagged when it moved from the baseline's. */
+export declare const ConfigVersionValue: ({ run }: {
+    run: SolutionTestRun;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/config-version.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { versionDelta } from "./utils.js";
+import { VersionDeltaGlyph } from "./version-delta-glyph.js";
+const ConfigVersionValue = ({ run })=>{
+    const { direction } = versionDelta(run.BaselineConfigVersion, run.ConfigVersion);
+    return /*#__PURE__*/ jsxs("span", {
+        className: "inline-flex items-center gap-1",
+        children: [
+            run.ConfigVersion ?? "-",
+            /*#__PURE__*/ jsx(VersionDeltaGlyph, {
+                direction: direction,
+                baseline: run.BaselineConfigVersion
+            })
+        ]
+    });
+};
+export { ConfigVersionValue };

package/dist/registry/solution-tests/config.d.ts

@@ -0,0 +1,117 @@
+import type { ColumnDef, Table as TanstackTable } from "@tanstack/react-table";
+import type { ReactNode } from "react";
+import type { EvaluatorRenderers } from "./evaluators/registry";
+import type { ProcessOutputRenderers } from "./outputs/registry";
+import type { SolutionTest, SolutionTestRun } from "./types";
+/**
+ * Telemetry events the Solution Tests actions emit, with payloads. The template
+ * names the events; the host supplies `track` (below) to route them. Compose
+ * into a host event map with `interface … extends SolutionTestEventMap {}` (not
+ * an intersection) so a generic tracker's `Map[K]` indexing keeps working.
+ */
+export interface SolutionTestEventMap {
+    "VS.SolutionTest.Run": {
+        mode: "all" | "test" | "selected";
+        testCount: number;
+    };
+    "VS.SolutionTest.Created": {
+        subjectId: string;
+    };
+    "VS.SolutionTest.ActiveToggled": {
+        testId: string;
+        isActive: boolean;
+    };
+    "VS.SolutionTest.Deleted": {
+        testId: string;
+    };
+    "VS.SolutionTest.BatchForceStopped": {
+        batchId: string;
+    };
+    "VS.SolutionTest.RunForceStopped": {
+        runId: string;
+    };
+    "VS.SolutionTest.JobAdopted": {
+        resultId: string;
+    };
+    "VS.SolutionTest.BaselineUpdated": {
+        resultId: string;
+    };
+    "VS.SolutionTest.BaselineRemoved": {
+        baselineId: string;
+    };
+    "VS.SolutionTest.TabViewed": {
+        tab: "cases" | "runs";
+    };
+    "VS.SolutionTest.TestExpanded": {
+        testId: string;
+    };
+    "VS.SolutionTest.BatchExpanded": {
+        batchId: string;
+    };
+    "VS.SolutionTest.RunDetailsOpened": {
+        runId: string;
+    };
+    "VS.SolutionTest.ResultViewed": {
+        resultId: string;
+    };
+    "VS.SolutionTest.RawOutputViewed": {
+        processName: string;
+    };
+}
+export type SolutionTestEventName = keyof SolutionTestEventMap;
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+/**
+ * Typed telemetry callback the host injects via config. An intersection of
+ * per-event signatures (not one generic signature) so a host tracker generic
+ * over a wider event map assigns to it cast-free.
+ */
+export type TrackSolutionTestEvent = UnionToIntersection<{
+    [K in SolutionTestEventName]: (event: K, properties: SolutionTestEventMap[K]) => void;
+}[SolutionTestEventName]>;
+/** Per-vertical presentation config; everything else is hard-coded in `constants`. */
+export interface SolutionTestsConfig {
+    /** Columns inserted between the Test Name and Version columns. */
+    subjectColumns?: ColumnDef<SolutionTest>[];
+    /** Custom content (e.g. faceted filters) rendered in the test-cases table toolbar. */
+    subjectToolbarContent?: (table: TanstackTable<SolutionTest>) => ReactNode;
+    /** When set, the test name links to its subject. */
+    getSubjectHref?: (test: SolutionTest) => string | undefined;
+    /** Opens a run's details. The host owns the route + navigation; the view
+     *  calls this when a run row is opened. Run details can't open without it. */
+    onOpenRun?: (run: SolutionTestRun) => void;
+    subjectNoun?: {
+        singular: string;
+        plural: string;
+    };
+    /** Score at/above which a result passes (drives pass color + KPI trend line). Defaults to 0.9. */
+    passThreshold?: number;
+    /** Show debug-only UI — the Expected/Actual input panels and the full
+     *  attachment fetch — in run-result details. Defaults to false. */
+    showDebug?: boolean;
+    /** Custom evaluator-id -> renderer map; wins over the built-in registry.
+     * The FE counterpart to the BE `custom_evaluator_builders`. */
+    evaluatorRenderers?: EvaluatorRenderers;
+    /** Keyed by stable agent id and/or process name; unmatched outputs render as raw JSON. */
+    outputRenderers?: ProcessOutputRenderers;
+    /** Emit a telemetry event for each action. No-op unless the host supplies it. */
+    track?: TrackSolutionTestEvent;
+}
+/** Config with defaults applied — what components read from context. */
+export interface ResolvedSolutionTestsConfig {
+    subjectColumns: ColumnDef<SolutionTest>[];
+    subjectToolbarContent?: (table: TanstackTable<SolutionTest>) => ReactNode;
+    getSubjectHref?: (test: SolutionTest) => string | undefined;
+    onOpenRun?: (run: SolutionTestRun) => void;
+    subjectNoun?: {
+        singular: string;
+        plural: string;
+    };
+    passThreshold: number;
+    showDebug: boolean;
+    evaluatorRenderers: EvaluatorRenderers;
+    outputRenderers: ProcessOutputRenderers;
+    /** Optional — call sites use `track?.(…)`, so no tracking happens if absent. */
+    track?: TrackSolutionTestEvent;
+}
+export declare function resolveConfig(config?: SolutionTestsConfig): ResolvedSolutionTestsConfig;
+export {};

package/dist/registry/solution-tests/config.js

@@ -0,0 +1,16 @@
+import { DEFAULT_PASS_THRESHOLD } from "./constants.js";
+function resolveConfig(config = {}) {
+    return {
+        subjectColumns: config.subjectColumns ?? [],
+        subjectToolbarContent: config.subjectToolbarContent,
+        getSubjectHref: config.getSubjectHref,
+        onOpenRun: config.onOpenRun,
+        subjectNoun: config.subjectNoun,
+        passThreshold: config.passThreshold ?? DEFAULT_PASS_THRESHOLD,
+        showDebug: config.showDebug ?? false,
+        evaluatorRenderers: config.evaluatorRenderers ?? {},
+        outputRenderers: config.outputRenderers ?? {},
+        track: config.track
+    };
+}
+export { resolveConfig };

package/dist/registry/solution-tests/constants.d.ts

@@ -0,0 +1,35 @@
+/** Setup constants for the Solution Tests view — collection names, trigger
+ *  slugs/paths, thresholds, and label maps. Edit here to retarget a deployment. */
+/** Placeholder rendered where a value is absent (missing baseline, no score). */
+export declare const EMPTY_VALUE = "\u2014";
+/** Well-known Solution Test collection names on `solution.api.collections.solutionTests`. */
+export declare const ENTITY: {
+    readonly tests: "UiPathSTTests";
+    readonly batchRuns: "UiPathSTBatchRuns";
+    readonly runs: "UiPathSTRuns";
+    readonly jobs: "UiPathSTJobs";
+    readonly runResults: "UiPathSTRunResults";
+};
+/** API-trigger slugs appended to the consumer's trigger base URL. */
+export declare const RUN_TESTS_SLUG = "run_solution_tests";
+export declare const AUTOMATION_FUNCTIONS_SLUG = "automation-functions";
+/** `automation-functions` RPC paths. */
+export declare const AUTOMATION_FUNCTION_PATH: {
+    readonly createTest: "/solution-tests/create";
+    readonly deleteTest: "/solution-tests/delete";
+    readonly forceStopBatch: "/solution-tests/force-stop-batch";
+    readonly forceStopRun: "/solution-tests/force-stop";
+    readonly adoptJob: "/solution-tests/adopt-job";
+    readonly updateBaseline: "/solution-tests/update-baseline";
+    readonly removeJobBaseline: "/solution-tests/remove-job-baseline";
+};
+/** Agent `output_data.status` values treated as success. */
+export declare const AGENT_SUCCESS_STATUSES: Set<string>;
+/** Default score ≥ threshold for a pass; overridable via `config.passThreshold`. */
+export declare const DEFAULT_PASS_THRESHOLD = 0.9;
+/** Most recent completed batches plotted on the KPI score-trend chart. */
+export declare const MAX_TREND_POINTS = 10;
+/** Numeric status enum → English label. */
+export declare const defaultTestStatusLabels: Record<number, string>;
+export declare const defaultRunStatusLabels: Record<number, string>;
+export declare const defaultRunResultStatusLabels: Record<number, string>;

package/dist/registry/solution-tests/constants.js

@@ -0,0 +1,49 @@
+import { RunResultStatus, RunStatus, SolutionTestStatus } from "./types.js";
+const EMPTY_VALUE = "—";
+const ENTITY = {
+    tests: "UiPathSTTests",
+    batchRuns: "UiPathSTBatchRuns",
+    runs: "UiPathSTRuns",
+    jobs: "UiPathSTJobs",
+    runResults: "UiPathSTRunResults"
+};
+const RUN_TESTS_SLUG = "run_solution_tests";
+const AUTOMATION_FUNCTIONS_SLUG = "automation-functions";
+const AUTOMATION_FUNCTION_PATH = {
+    createTest: "/solution-tests/create",
+    deleteTest: "/solution-tests/delete",
+    forceStopBatch: "/solution-tests/force-stop-batch",
+    forceStopRun: "/solution-tests/force-stop",
+    adoptJob: "/solution-tests/adopt-job",
+    updateBaseline: "/solution-tests/update-baseline",
+    removeJobBaseline: "/solution-tests/remove-job-baseline"
+};
+const AGENT_SUCCESS_STATUSES = new Set([
+    "success",
+    "partial_success"
+]);
+const DEFAULT_PASS_THRESHOLD = 0.9;
+const MAX_TREND_POINTS = 10;
+const defaultTestStatusLabels = {
+    [SolutionTestStatus.Pending]: "Pending",
+    [SolutionTestStatus.Ready]: "Ready",
+    [SolutionTestStatus.Error]: "Error"
+};
+const defaultRunStatusLabels = {
+    [RunStatus.Pending]: "Pending",
+    [RunStatus.Running]: "Running",
+    [RunStatus.Passed]: "Passed",
+    [RunStatus.Failed]: "Failed",
+    [RunStatus.Error]: "Error",
+    [RunStatus.Aborted]: "Aborted"
+};
+const defaultRunResultStatusLabels = {
+    [RunResultStatus.Pending]: "Pending",
+    [RunResultStatus.Passed]: "Passed",
+    [RunResultStatus.Failed]: "Failed",
+    [RunResultStatus.Error]: "Error",
+    [RunResultStatus.NoBaseline]: "New",
+    [RunResultStatus.Missing]: "Did not run",
+    [RunResultStatus.Aborted]: "Aborted"
+};
+export { AGENT_SUCCESS_STATUSES, AUTOMATION_FUNCTIONS_SLUG, AUTOMATION_FUNCTION_PATH, DEFAULT_PASS_THRESHOLD, EMPTY_VALUE, ENTITY, MAX_TREND_POINTS, RUN_TESTS_SLUG, defaultRunResultStatusLabels, defaultRunStatusLabels, defaultTestStatusLabels };

package/dist/registry/solution-tests/context.d.ts

@@ -0,0 +1,27 @@
+/** Provides the view's presentation config + trigger-backed write actions. */
+import { type ReactNode } from "react";
+import type { SolutionTestsActions } from "./actions";
+import { type ResolvedSolutionTestsConfig, type SolutionTestsConfig } from "./config";
+interface SolutionTestsContextValue {
+    config: ResolvedSolutionTestsConfig;
+    actions: SolutionTestsActions;
+    attachmentScope?: () => {
+        folderKey?: string;
+    };
+}
+interface SolutionTestsProviderProps {
+    config?: SolutionTestsConfig;
+    /** Base URL each action slug is appended to (no trailing slash). */
+    triggerBaseUrl: string;
+    getToken: () => Promise<string | null> | string | null;
+    /** Folder scope forwarded to entity attachment downloads (in-solution hosting). */
+    attachmentScope?: () => {
+        folderKey?: string;
+    };
+    children: ReactNode;
+}
+export declare const SolutionTestsProvider: ({ config, triggerBaseUrl, getToken, attachmentScope, children, }: SolutionTestsProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare function useSolutionTestsContext(): SolutionTestsContextValue;
+export declare function useSolutionTestsConfig(): ResolvedSolutionTestsConfig;
+export declare function useSolutionTestsActions(): SolutionTestsActions;
+export {};

package/dist/registry/solution-tests/context.js

@@ -0,0 +1,37 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { resolveConfig } from "./config.js";
+import { createSolutionTestActions } from "./create-actions.js";
+const SolutionTestsContext = /*#__PURE__*/ createContext(null);
+const SolutionTestsProvider = ({ config, triggerBaseUrl, getToken, attachmentScope, children })=>{
+    const value = useMemo(()=>({
+            config: resolveConfig(config),
+            actions: createSolutionTestActions({
+                triggerBaseUrl,
+                getToken
+            }),
+            attachmentScope
+        }), [
+        config,
+        triggerBaseUrl,
+        getToken,
+        attachmentScope
+    ]);
+    return /*#__PURE__*/ jsx(SolutionTestsContext.Provider, {
+        value: value,
+        children: children
+    });
+};
+function useSolutionTestsContext() {
+    const ctx = useContext(SolutionTestsContext);
+    if (!ctx) throw new Error("useSolutionTestsContext must be used within a SolutionTestsProvider");
+    return ctx;
+}
+function useSolutionTestsConfig() {
+    return useSolutionTestsContext().config;
+}
+function useSolutionTestsActions() {
+    return useSolutionTestsContext().actions;
+}
+export { SolutionTestsProvider, useSolutionTestsActions, useSolutionTestsConfig, useSolutionTestsContext };

package/dist/registry/solution-tests/create-actions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builds the Solution Tests write actions: `run` hits the `run_solution_tests`
+ * trigger; delete/adopt/baseline/force-stop go through the `automation-functions`
+ * RPC trigger. Each POSTs `{triggerBaseUrl}/{slug}` with the bearer token in the
+ * header and echoed in the body for backend RBAC.
+ */
+import type { SolutionTestsActions } from "./actions";
+export interface SolutionTestActionDeps {
+    /** Base URL each action slug is appended to (no trailing slash). */
+    triggerBaseUrl: string;
+    getToken: () => Promise<string | null> | string | null;
+}
+export declare function createSolutionTestActions(deps: SolutionTestActionDeps): SolutionTestsActions;

package/dist/registry/solution-tests/create-actions.js

@@ -0,0 +1,91 @@
+"use client";
+import { AUTOMATION_FUNCTIONS_SLUG, AUTOMATION_FUNCTION_PATH, RUN_TESTS_SLUG } from "./constants.js";
+import { SolutionTestActionError, extractFailure } from "./errors.js";
+function createSolutionTestActions(deps) {
+    const { triggerBaseUrl, getToken } = deps;
+    async function invokeTrigger(slug, buildBody) {
+        const token = await getToken();
+        if (!token) throw new Error("No access token available.");
+        let response;
+        try {
+            response = await fetch(`${triggerBaseUrl}/${slug}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    Accept: "application/json"
+                },
+                body: JSON.stringify(buildBody(token))
+            });
+        } catch (error) {
+            throw error instanceof Error ? error : new Error("Network request failed.");
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`API trigger returned ${response.status}: ${text.slice(0, 300)}`);
+        }
+        const data = response.headers.get("content-type")?.includes("application/json") ? await response.json().catch(()=>null) : null;
+        const failure = extractFailure(data);
+        if (failure) throw new SolutionTestActionError(failure);
+    }
+    function callFn(path, body) {
+        return invokeTrigger(AUTOMATION_FUNCTIONS_SLUG, (token)=>({
+                method: "POST",
+                path,
+                body: {
+                    ...body,
+                    _auth: {
+                        userToken: token
+                    }
+                }
+            }));
+    }
+    return {
+        runTests (testIds) {
+            return invokeTrigger(RUN_TESTS_SLUG, (token)=>({
+                    ...testIds ? {
+                        solution_test_ids: testIds
+                    } : {},
+                    auth: {
+                        userToken: token
+                    }
+                }));
+        },
+        createTest (subjectId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.createTest, {
+                subject_id: subjectId
+            });
+        },
+        deleteTest (testId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.deleteTest, {
+                solution_test_id: testId
+            });
+        },
+        forceStopBatch (batchId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.forceStopBatch, {
+                batch_id: batchId
+            });
+        },
+        forceStopRun (runId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.forceStopRun, {
+                run_id: runId
+            });
+        },
+        adoptJob (runResultId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.adoptJob, {
+                run_result_id: runResultId
+            });
+        },
+        updateBaseline (runResultId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.updateBaseline, {
+                run_result_id: runResultId
+            });
+        },
+        removeJobBaseline (jobBaselineId) {
+            return callFn(AUTOMATION_FUNCTION_PATH.removeJobBaseline, {
+                job_baseline_id: jobBaselineId
+            });
+        }
+    };
+}
+export { createSolutionTestActions };

package/dist/registry/solution-tests/delete-confirm-dialog.d.ts

@@ -0,0 +1,8 @@
+interface DeleteConfirmDialogProps {
+    open: boolean;
+    deleting: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+}
+export declare const DeleteConfirmDialog: ({ open, deleting, onConfirm, onCancel, }: DeleteConfirmDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/solution-tests/delete-confirm-dialog.js

@@ -0,0 +1,52 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Button } from "../button/button.js";
+import { Spinner } from "../spinner/spinner.js";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "../dialog/dialog.js";
+const DeleteConfirmDialog = ({ open, deleting, onConfirm, onCancel })=>{
+    const { t } = useVertexTranslation();
+    return /*#__PURE__*/ jsx(Dialog, {
+        open: open,
+        onOpenChange: (isOpen)=>{
+            if (!isOpen) onCancel();
+        },
+        children: /*#__PURE__*/ jsxs(DialogContent, {
+            children: [
+                /*#__PURE__*/ jsxs(DialogHeader, {
+                    children: [
+                        /*#__PURE__*/ jsx(DialogTitle, {
+                            children: t("confirm_delete_test")
+                        }),
+                        /*#__PURE__*/ jsx(DialogDescription, {
+                            children: t("confirm_delete_test_description")
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "flex justify-end gap-2 pt-4",
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            variant: "outline",
+                            onClick: onCancel,
+                            disabled: deleting,
+                            children: t("cancel")
+                        }),
+                        /*#__PURE__*/ jsxs(Button, {
+                            variant: "destructive",
+                            onClick: onConfirm,
+                            disabled: deleting,
+                            children: [
+                                deleting ? /*#__PURE__*/ jsx(Spinner, {
+                                    className: "size-4"
+                                }) : null,
+                                t("delete")
+                            ]
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+export { DeleteConfirmDialog };

package/dist/registry/solution-tests/errors.d.ts

@@ -0,0 +1,15 @@
+export interface ActionFailure {
+    /** Stable failure code; consumers may map it to a localized message. */
+    key?: string;
+    /** Interpolation params for the localized message (e.g. `required_roles`). */
+    details?: Record<string, string>;
+    message?: string;
+}
+/** Thrown by the write actions on an app-level failure (HTTP stays 200). */
+export declare class SolutionTestActionError extends Error {
+    readonly key?: string;
+    readonly details?: Record<string, string>;
+    constructor(failure: ActionFailure);
+}
+/** Detect an app-level failure across both contracts, or null on success. */
+export declare function extractFailure(data: unknown): ActionFailure | null;