@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/combobox/combobox.js

@@ -0,0 +1,187 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AlertTriangleIcon, CheckIcon, ChevronsUpDownIcon, XIcon } from "lucide-react";
+import { createContext, use, useState } from "react";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Badge } from "../badge/badge.js";
+import { buttonVariants } from "../button/button.js";
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "../command/command.js";
+import { Popover, PopoverContent, PopoverTrigger } from "../popover/popover.js";
+import { cn } from "../../lib/utils.js";
+const ComboboxContext = /*#__PURE__*/ createContext(null);
+function useComboboxContext() {
+    const context = use(ComboboxContext);
+    if (!context) throw new Error("Combobox components must be used within a <Combobox />");
+    return context;
+}
+function Combobox({ open: controlledOpen, onOpenChange, multiple = false, value: controlledValue, onValueChange, children }) {
+    const [uncontrolledOpen, setUncontrolledOpen] = useState(false);
+    const [uncontrolledValue, setUncontrolledValue] = useState([]);
+    const isValueControlled = null != controlledValue;
+    const open = controlledOpen ?? uncontrolledOpen;
+    const value = controlledValue ?? uncontrolledValue;
+    function setOpen(next) {
+        (null == controlledOpen ? setUncontrolledOpen : onOpenChange)?.(next);
+    }
+    function handleValueChange(next) {
+        const handler = isValueControlled ? onValueChange : setUncontrolledValue;
+        handler?.(next);
+        if (!multiple) setOpen(false);
+    }
+    const contextValue = {
+        open,
+        multiple,
+        value,
+        onValueChange: handleValueChange
+    };
+    return /*#__PURE__*/ jsx(ComboboxContext, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(Popover, {
+            open: open,
+            onOpenChange: setOpen,
+            children: children
+        })
+    });
+}
+function ComboboxTrigger({ className, placeholder, children, "aria-invalid": ariaInvalid, ...props }) {
+    const { open } = useComboboxContext();
+    const isInvalid = "true" === ariaInvalid || true === ariaInvalid;
+    return /*#__PURE__*/ jsx(PopoverTrigger, {
+        asChild: true,
+        children: /*#__PURE__*/ jsxs("div", {
+            "data-slot": "combobox-trigger",
+            role: "combobox",
+            tabIndex: 0,
+            "aria-expanded": open,
+            "aria-haspopup": "listbox",
+            "aria-invalid": ariaInvalid,
+            className: cn(buttonVariants({
+                variant: "outline"
+            }), "w-full justify-between font-normal", !children && "text-muted-foreground", className),
+            ...props,
+            children: [
+                children ?? /*#__PURE__*/ jsx("span", {
+                    className: "truncate",
+                    children: placeholder
+                }),
+                /*#__PURE__*/ jsxs("span", {
+                    className: "ml-auto flex items-center gap-1",
+                    children: [
+                        isInvalid && /*#__PURE__*/ jsx(AlertTriangleIcon, {
+                            className: "size-4 shrink-0 text-destructive"
+                        }),
+                        /*#__PURE__*/ jsx(ChevronsUpDownIcon, {
+                            className: "size-4 shrink-0 opacity-50"
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+function ComboboxContent({ className, children, filter, ...props }) {
+    return /*#__PURE__*/ jsx(PopoverContent, {
+        "data-slot": "combobox-content",
+        className: cn("w-(--radix-popover-trigger-width) p-0", className),
+        ...props,
+        children: /*#__PURE__*/ jsx(Command, {
+            filter: filter,
+            children: children
+        })
+    });
+}
+function ComboboxInput({ ...props }) {
+    return /*#__PURE__*/ jsx(CommandInput, {
+        "data-slot": "combobox-input",
+        ...props
+    });
+}
+function ComboboxList({ className, ...props }) {
+    return /*#__PURE__*/ jsx(CommandList, {
+        "data-slot": "combobox-list",
+        className: cn("max-h-[300px]", className),
+        ...props
+    });
+}
+function ComboboxEmpty({ ...props }) {
+    return /*#__PURE__*/ jsx(CommandEmpty, {
+        "data-slot": "combobox-empty",
+        ...props
+    });
+}
+function ComboboxGroup({ ...props }) {
+    return /*#__PURE__*/ jsx(CommandGroup, {
+        "data-slot": "combobox-group",
+        ...props
+    });
+}
+function ComboboxItem({ className, value: itemValue, children, ...props }) {
+    const { value: selectedValues, multiple, onValueChange } = useComboboxContext();
+    const isSelected = selectedValues.includes(itemValue);
+    function handleSelect() {
+        const next = isSelected ? selectedValues.filter((v)=>v !== itemValue) : multiple ? [
+            ...selectedValues,
+            itemValue
+        ] : [
+            itemValue
+        ];
+        onValueChange(next);
+    }
+    return /*#__PURE__*/ jsxs(CommandItem, {
+        "data-slot": "combobox-item",
+        "data-selected": isSelected,
+        value: itemValue,
+        onSelect: handleSelect,
+        className: cn(className),
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx(CheckIcon, {
+                className: cn("size-4 shrink-0", isSelected ? "opacity-100" : "opacity-0")
+            }),
+            children
+        ]
+    });
+}
+function ComboboxBadgeList({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "combobox-badge-list",
+        className: cn("flex flex-wrap gap-1", className),
+        ...props
+    });
+}
+function ComboboxBadge({ className, value: itemValue, onRemove, children, ...props }) {
+    const { t } = useVertexTranslation();
+    const { value: selectedValues, onValueChange } = useComboboxContext();
+    function handleRemove(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        const handler = onRemove ?? (()=>onValueChange(selectedValues.filter((v)=>v !== itemValue)));
+        handler();
+    }
+    return /*#__PURE__*/ jsxs(Badge, {
+        "data-slot": "combobox-badge",
+        variant: "secondary",
+        className: cn("gap-1 pr-1", className),
+        ...props,
+        children: [
+            children,
+            /*#__PURE__*/ jsxs("button", {
+                type: "button",
+                "data-slot": "combobox-badge-remove",
+                className: "rounded-full p-0.5 hover:bg-foreground/20",
+                onClick: handleRemove,
+                onKeyDown: (e)=>("Enter" === e.key || " " === e.key) && handleRemove(e),
+                children: [
+                    /*#__PURE__*/ jsx(XIcon, {
+                        className: "size-3"
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "sr-only",
+                        children: t("remove")
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { Combobox, ComboboxBadge, ComboboxBadgeList, ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxInput, ComboboxItem, ComboboxList, ComboboxTrigger };

package/dist/registry/command/command.d.ts

@@ -0,0 +1,18 @@
+import { Command as CommandPrimitive } from "cmdk";
+import * as React from "react";
+import { Dialog } from "../dialog/dialog";
+declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+declare function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function CommandItem({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/registry/command/command.js

@@ -0,0 +1,99 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Command } from "cmdk";
+import { SearchIcon } from "lucide-react";
+import "react";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "../dialog/dialog.js";
+import { cn } from "../../lib/utils.js";
+function command_Command({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Command, {
+        "data-slot": "command",
+        className: cn("bg-popover text-popover-foreground flex h-full w-full flex-col overflow-hidden rounded-md", className),
+        ...props
+    });
+}
+function CommandDialog({ title = "Command Palette", description = "Search for a command to run...", children, className, showCloseButton = true, ...props }) {
+    return /*#__PURE__*/ jsxs(Dialog, {
+        ...props,
+        children: [
+            /*#__PURE__*/ jsxs(DialogHeader, {
+                className: "sr-only",
+                children: [
+                    /*#__PURE__*/ jsx(DialogTitle, {
+                        children: title
+                    }),
+                    /*#__PURE__*/ jsx(DialogDescription, {
+                        children: description
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(DialogContent, {
+                className: cn("overflow-hidden p-0", className),
+                showCloseButton: showCloseButton,
+                children: /*#__PURE__*/ jsx(command_Command, {
+                    className: "[&_[cmdk-group-heading]]:text-muted-foreground **:data-[slot=command-input-wrapper]:h-12 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group]]:px-2 [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5",
+                    children: children
+                })
+            })
+        ]
+    });
+}
+function CommandInput({ className, ...props }) {
+    return /*#__PURE__*/ jsxs("div", {
+        "data-slot": "command-input-wrapper",
+        className: "flex h-9 items-center gap-2 border-b px-3",
+        children: [
+            /*#__PURE__*/ jsx(SearchIcon, {
+                className: "size-4 shrink-0 opacity-50"
+            }),
+            /*#__PURE__*/ jsx(Command.Input, {
+                "data-slot": "command-input",
+                className: cn("placeholder:text-muted-foreground flex h-10 w-full rounded-md bg-transparent py-3 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50", className),
+                ...props
+            })
+        ]
+    });
+}
+function CommandList({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Command.List, {
+        "data-slot": "command-list",
+        className: cn("max-h-[300px] scroll-py-1 overflow-x-hidden overflow-y-auto", className),
+        ...props
+    });
+}
+function CommandEmpty({ ...props }) {
+    return /*#__PURE__*/ jsx(Command.Empty, {
+        "data-slot": "command-empty",
+        className: "py-6 text-center text-sm",
+        ...props
+    });
+}
+function CommandGroup({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Command.Group, {
+        "data-slot": "command-group",
+        className: cn("text-foreground [&_[cmdk-group-heading]]:text-muted-foreground overflow-hidden p-1 [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium", className),
+        ...props
+    });
+}
+function CommandSeparator({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Command.Separator, {
+        "data-slot": "command-separator",
+        className: cn("bg-border -mx-1 h-px", className),
+        ...props
+    });
+}
+function CommandItem({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Command.Item, {
+        "data-slot": "command-item",
+        className: cn("data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        ...props
+    });
+}
+function CommandShortcut({ className, ...props }) {
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "command-shortcut",
+        className: cn("text-muted-foreground ml-auto text-xs tracking-widest", className),
+        ...props
+    });
+}
+export { command_Command as Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut };

package/dist/registry/confidence-signal/confidence-signal-bars.d.ts

@@ -0,0 +1,8 @@
+import { type ConfidenceLevel } from "./confidence-signal-levels";
+declare function SignalBars({ level, size, animateIn, className, }: {
+    level: ConfidenceLevel;
+    size?: number;
+    animateIn?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { SignalBars };

package/dist/registry/confidence-signal/confidence-signal-bars.js

@@ -0,0 +1,73 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { motion, useReducedMotion } from "framer-motion";
+import { cn } from "../../lib/utils.js";
+import { LEVEL_CONFIG } from "./confidence-signal-levels.js";
+const BAR_HEIGHTS = [
+    8,
+    13,
+    18
+];
+const ACQUIRE_KEYFRAMES = {
+    scaleY: [
+        1,
+        0.05,
+        1
+    ]
+};
+const ACQUIRE_TIMES = [
+    0,
+    0.3,
+    1
+];
+const ACQUIRE_DURATION = 0.42;
+const ACQUIRE_STAGGER = 0.09;
+const BAR_TRANSFORM_ORIGIN = {
+    transformBox: "fill-box",
+    transformOrigin: "bottom"
+};
+function SignalBars({ level, size = 14, animateIn = false, className }) {
+    const { filled, solid, faded } = LEVEL_CONFIG[level];
+    const prefersReducedMotion = useReducedMotion();
+    const animate = animateIn && !prefersReducedMotion;
+    const scale = size / 18;
+    return /*#__PURE__*/ jsxs("svg", {
+        width: 24 * scale,
+        height: size,
+        viewBox: "0 0 24 18",
+        fill: "none",
+        overflow: "visible",
+        className: cn("shrink-0", className),
+        "aria-hidden": "true",
+        children: [
+            animate && BAR_HEIGHTS.map((h, i)=>/*#__PURE__*/ jsx("rect", {
+                    x: 9 * i,
+                    y: 18 - h,
+                    width: 6,
+                    height: h,
+                    rx: 3,
+                    fill: faded
+                }, `track-${h}`)),
+            BAR_HEIGHTS.map((h, i)=>/*#__PURE__*/ jsx(motion.rect, {
+                    "data-slot": "confidence-signal-bar",
+                    x: 9 * i,
+                    y: 18 - h,
+                    width: 6,
+                    height: h,
+                    rx: 3,
+                    fill: i < filled ? solid : faded,
+                    ...animate ? {
+                        style: BAR_TRANSFORM_ORIGIN,
+                        animate: ACQUIRE_KEYFRAMES,
+                        transition: {
+                            duration: ACQUIRE_DURATION,
+                            times: ACQUIRE_TIMES,
+                            delay: i * ACQUIRE_STAGGER,
+                            ease: "easeInOut"
+                        }
+                    } : {}
+                }, h))
+        ]
+    });
+}
+export { SignalBars };

package/dist/registry/confidence-signal/confidence-signal-chip.d.ts

@@ -0,0 +1,15 @@
+import type * as React from "react";
+import { type ConfidenceLevel } from "./confidence-signal-levels";
+export interface ConfidenceSignalChipProps extends Omit<React.ComponentProps<"button">, "children"> {
+    level: ConfidenceLevel;
+    /** Visible label. Omit for the icon-only (`min`) variant. */
+    label?: string;
+    /** Full level name, always announced to assistive tech. */
+    accessibleLabel: string;
+    /** Play the one-time "acquire" bar animation. */
+    animateIn?: boolean;
+    /** Whether the chip opens a details popover, which drives the cursor. */
+    interactive?: boolean;
+}
+declare function ConfidenceSignalChip({ level, label, accessibleLabel, animateIn, interactive, className, ...props }: ConfidenceSignalChipProps): import("react/jsx-runtime").JSX.Element;
+export { ConfidenceSignalChip };

package/dist/registry/confidence-signal/confidence-signal-chip.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+import { SignalBars } from "./confidence-signal-bars.js";
+import { LEVEL_CONFIG } from "./confidence-signal-levels.js";
+function ConfidenceSignalChip({ level, label, accessibleLabel, animateIn = false, interactive = false, className, ...props }) {
+    return /*#__PURE__*/ jsxs("button", {
+        className: cn("inline-flex items-center gap-1.5 text-xs font-semibold focus-visible:outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50", LEVEL_CONFIG[level].textClass, interactive && "cursor-pointer", className),
+        "aria-label": accessibleLabel,
+        ...props,
+        type: "button",
+        "data-slot": "confidence-signal",
+        "data-level": level,
+        children: [
+            /*#__PURE__*/ jsx(SignalBars, {
+                level: level,
+                animateIn: animateIn
+            }),
+            label
+        ]
+    });
+}
+export { ConfidenceSignalChip };

package/dist/registry/confidence-signal/confidence-signal-cta.d.ts

@@ -0,0 +1,11 @@
+import type { ConfidenceCta } from "./confidence-signal-levels";
+/**
+ * Renders a confidence CTA. With `href` it is an anchor so the target is
+ * navigable, middle-clickable, and copyable; without one it falls back to a
+ * plain button driven by `onClick`.
+ */
+declare function ConfidenceSignalCta({ cta, className, }: {
+    cta: ConfidenceCta;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { ConfidenceSignalCta };

package/dist/registry/confidence-signal/confidence-signal-cta.js

@@ -0,0 +1,35 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { ArrowUpRight } from "lucide-react";
+import { Button } from "../button/button.js";
+import { cn } from "../../lib/utils.js";
+function ConfidenceSignalCta({ cta, className }) {
+    const content = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            cta.label,
+            /*#__PURE__*/ jsx(ArrowUpRight, {
+                className: "size-3",
+                "aria-hidden": "true"
+            })
+        ]
+    });
+    if (cta.href) return /*#__PURE__*/ jsx(Button, {
+        asChild: true,
+        variant: "outline",
+        size: "sm",
+        className: cn("w-full", className),
+        children: /*#__PURE__*/ jsx("a", {
+            href: cta.href,
+            onClick: cta.onClick,
+            children: content
+        })
+    });
+    return /*#__PURE__*/ jsx(Button, {
+        variant: "outline",
+        size: "sm",
+        className: cn("w-full", className),
+        onClick: cta.onClick,
+        children: content
+    });
+}
+export { ConfidenceSignalCta };

package/dist/registry/confidence-signal/confidence-signal-factors.d.ts

@@ -0,0 +1,8 @@
+import { type ConfidenceFactor } from "./confidence-signal-levels";
+declare function ConfidenceSignalFactorRow({ factor }: {
+    factor: ConfidenceFactor;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ConfidenceSignalFactors({ factors }: {
+    factors: ConfidenceFactor[];
+}): import("react/jsx-runtime").JSX.Element;
+export { ConfidenceSignalFactors, ConfidenceSignalFactorRow };

package/dist/registry/confidence-signal/confidence-signal-factors.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+import { FACTOR_STATUS_CLASS } from "./confidence-signal-levels.js";
+function ConfidenceSignalFactorRow({ factor }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex items-center justify-between gap-2",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "text-xs text-muted-foreground",
+                children: factor.label
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: cn("text-xs font-medium", factor.status ? FACTOR_STATUS_CLASS[factor.status] : "text-foreground"),
+                children: factor.value
+            })
+        ]
+    });
+}
+function ConfidenceSignalFactors({ factors }) {
+    return /*#__PURE__*/ jsx("div", {
+        className: "flex flex-col gap-1.5 border-t border-border pt-3",
+        children: factors.map((factor)=>/*#__PURE__*/ jsx(ConfidenceSignalFactorRow, {
+                factor: factor
+            }, `${factor.label}:${factor.value}`))
+    });
+}
+export { ConfidenceSignalFactorRow, ConfidenceSignalFactors };

package/dist/registry/confidence-signal/confidence-signal-levels.d.ts

@@ -0,0 +1,89 @@
+export type ConfidenceLevel = "high" | "medium" | "low" | "unknown";
+export interface ConfidenceFactor {
+    /** Short label for the factor, e.g. "Historical accuracy" */
+    label: string;
+    /** Value or short note, e.g. "94% match" */
+    value: string;
+    /** Optional status tint for the value. */
+    status?: "success" | "warning" | "error";
+}
+interface ConfidenceCtaBase {
+    label: string;
+}
+/**
+ * A CTA has to do something, so at least one of `href` and `onClick` is
+ * required: a CTA with neither renders a control that looks interactive and
+ * does nothing. `href` renders an anchor, so the target stays navigable,
+ * middle-clickable, and copyable.
+ */
+export type ConfidenceCta = ConfidenceCtaBase & ({
+    href: string;
+    onClick?: () => void;
+} | {
+    href?: undefined;
+    onClick: () => void;
+});
+/**
+ * Per-level presentation and copy.
+ *
+ * Copy is a translation key plus the English source string. The key is what
+ * the translation pipeline picks up from `locales/en.json`; the source string
+ * is passed to `t` as `defaultValue` so the component still reads correctly
+ * when it is dropped into an app that has not configured i18next.
+ *
+ * Bar colors stay as literal hues rather than theme tokens: the signal-bar
+ * metaphor relies on a fixed green/amber/red ramp that reads the same in every
+ * theme, the way a battery or wifi icon does.
+ */
+export declare const LEVEL_CONFIG: {
+    readonly high: {
+        readonly labelKey: "confidence_signal_high_label";
+        readonly labelText: "High confidence";
+        readonly shortLabelKey: "confidence_signal_high_short";
+        readonly shortLabelText: "High";
+        readonly explanationKey: "confidence_signal_high_explanation";
+        readonly explanationText: "The output is well-supported and reliable.";
+        readonly textClass: "text-success";
+        readonly filled: 3;
+        readonly solid: "#15803d";
+        readonly faded: "#bbf7d0";
+    };
+    readonly medium: {
+        readonly labelKey: "confidence_signal_medium_label";
+        readonly labelText: "Medium confidence";
+        readonly shortLabelKey: "confidence_signal_medium_short";
+        readonly shortLabelText: "Medium";
+        readonly explanationKey: "confidence_signal_medium_explanation";
+        readonly explanationText: "Some uncertainty remains — review before acting.";
+        readonly textClass: "text-warning-foreground dark:text-warning";
+        readonly filled: 2;
+        readonly solid: "#b45309";
+        readonly faded: "#fde68a";
+    };
+    readonly low: {
+        readonly labelKey: "confidence_signal_low_label";
+        readonly labelText: "Low confidence";
+        readonly shortLabelKey: "confidence_signal_low_short";
+        readonly shortLabelText: "Low";
+        readonly explanationKey: "confidence_signal_low_explanation";
+        readonly explanationText: "Limited evidence — verify this before relying on it.";
+        readonly textClass: "text-destructive";
+        readonly filled: 1;
+        readonly solid: "#991b1b";
+        readonly faded: "#fecaca";
+    };
+    readonly unknown: {
+        readonly labelKey: "confidence_signal_unknown_label";
+        readonly labelText: "Unknown confidence";
+        readonly shortLabelKey: "confidence_signal_unknown_short";
+        readonly shortLabelText: "Unknown";
+        readonly explanationKey: "confidence_signal_unknown_explanation";
+        readonly explanationText: "The system cannot determine an answer reliably.";
+        readonly textClass: "text-foreground";
+        readonly filled: 0;
+        readonly solid: "#9ca3af";
+        readonly faded: "#e5e7eb";
+    };
+};
+export declare const FACTOR_STATUS_CLASS: Record<NonNullable<ConfidenceFactor["status"]>, string>;
+export {};

package/dist/registry/confidence-signal/confidence-signal-levels.js

@@ -0,0 +1,56 @@
+const LEVEL_CONFIG = {
+    high: {
+        labelKey: "confidence_signal_high_label",
+        labelText: "High confidence",
+        shortLabelKey: "confidence_signal_high_short",
+        shortLabelText: "High",
+        explanationKey: "confidence_signal_high_explanation",
+        explanationText: "The output is well-supported and reliable.",
+        textClass: "text-success",
+        filled: 3,
+        solid: "#15803d",
+        faded: "#bbf7d0"
+    },
+    medium: {
+        labelKey: "confidence_signal_medium_label",
+        labelText: "Medium confidence",
+        shortLabelKey: "confidence_signal_medium_short",
+        shortLabelText: "Medium",
+        explanationKey: "confidence_signal_medium_explanation",
+        explanationText: "Some uncertainty remains — review before acting.",
+        textClass: "text-warning-foreground dark:text-warning",
+        filled: 2,
+        solid: "#b45309",
+        faded: "#fde68a"
+    },
+    low: {
+        labelKey: "confidence_signal_low_label",
+        labelText: "Low confidence",
+        shortLabelKey: "confidence_signal_low_short",
+        shortLabelText: "Low",
+        explanationKey: "confidence_signal_low_explanation",
+        explanationText: "Limited evidence — verify this before relying on it.",
+        textClass: "text-destructive",
+        filled: 1,
+        solid: "#991b1b",
+        faded: "#fecaca"
+    },
+    unknown: {
+        labelKey: "confidence_signal_unknown_label",
+        labelText: "Unknown confidence",
+        shortLabelKey: "confidence_signal_unknown_short",
+        shortLabelText: "Unknown",
+        explanationKey: "confidence_signal_unknown_explanation",
+        explanationText: "The system cannot determine an answer reliably.",
+        textClass: "text-foreground",
+        filled: 0,
+        solid: "#9ca3af",
+        faded: "#e5e7eb"
+    }
+};
+const FACTOR_STATUS_CLASS = {
+    success: "text-success",
+    warning: "text-warning-foreground dark:text-warning",
+    error: "text-destructive"
+};
+export { FACTOR_STATUS_CLASS, LEVEL_CONFIG };