@sequenceholdings/atlas-ui 0.1.2 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,4064 @@
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { ClassProp } from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import { ColumnDef } from '@tanstack/react-table';
+import { ColumnFiltersState } from '@tanstack/react-table';
+import { Command as Command_2 } from 'cmdk';
+import { ComponentProps } from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { DayPicker } from 'react-day-picker';
+import { default as default_2 } from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { Dispatch } from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import { InputProps as InputProps_2 } from 'src';
+import { JSX } from 'react/jsx-runtime';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { QueryKey } from '@tanstack/react-query';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import * as RechartsPrimitive from 'recharts';
+import { Row } from '@tanstack/react-table';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import { SetStateAction } from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import { SortingState } from '@tanstack/react-table';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import { Table as Table_2 } from '@tanstack/react-table';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { toast } from 'sonner';
+import { ToasterProps } from 'sonner';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { UseMutationResult } from '@tanstack/react-query';
+import { VariantProps } from 'class-variance-authority';
+
+export declare const AGENT_TINTS: {
+    readonly teal: {
+        readonly bg: "bg-teal-50 dark:bg-teal-500/10";
+        readonly fg: "text-teal-700 dark:text-teal-300";
+    };
+    readonly violet: {
+        readonly bg: "bg-violet-50 dark:bg-violet-500/10";
+        readonly fg: "text-violet-700 dark:text-violet-300";
+    };
+    readonly amber: {
+        readonly bg: "bg-amber-50 dark:bg-amber-500/10";
+        readonly fg: "text-amber-700 dark:text-amber-300";
+    };
+    readonly rose: {
+        readonly bg: "bg-rose-50 dark:bg-rose-500/10";
+        readonly fg: "text-rose-700 dark:text-rose-300";
+    };
+    readonly sky: {
+        readonly bg: "bg-sky-50 dark:bg-sky-500/10";
+        readonly fg: "text-sky-700 dark:text-sky-300";
+    };
+    readonly emerald: {
+        readonly bg: "bg-emerald-50 dark:bg-emerald-500/10";
+        readonly fg: "text-emerald-700 dark:text-emerald-300";
+    };
+    readonly orange: {
+        readonly bg: "bg-orange-50 dark:bg-orange-500/10";
+        readonly fg: "text-orange-700 dark:text-orange-300";
+    };
+    readonly indigo: {
+        readonly bg: "bg-indigo-50 dark:bg-indigo-500/10";
+        readonly fg: "text-indigo-700 dark:text-indigo-300";
+    };
+    readonly graphite: {
+        readonly bg: "bg-muted";
+        readonly fg: "text-foreground";
+    };
+};
+
+export declare type AgentTint = keyof typeof AGENT_TINTS;
+
+export declare const AlertDialog: React_2.FC<AlertDialogPrimitive.AlertDialogProps>;
+
+export declare const AlertDialogAction: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const AlertDialogCancel: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const AlertDialogContent: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    /**
+     * Classes for the scrim behind the dialog. Pair with `className` when
+     * raising z-index — a lone `className="z-modal"` lifts only the panel and
+     * leaves the overlay at `z-50` (DES-315). Additive; defaults unchanged.
+     */
+    overlayClassName?: string;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AlertDialogDescription: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const AlertDialogFooter: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const AlertDialogHeader: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const AlertDialogOverlay: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare function AlertDialogPortal({ container, ...props }: React_2.ComponentProps<typeof AlertDialogPrimitive.Portal>): JSX.Element;
+
+export declare const AlertDialogTitle: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare const AlertDialogTrigger: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Lifecycle status for an Atlas app.
+ *
+ * GA is intentionally NOT a member of this union. GA = no badge, signaled by
+ * `App.status` being absent. Adding `'ga'` would suggest you could set it
+ * explicitly, but no renderer draws anything for GA — the truthy check on
+ * `status` is the "show a badge" gate in `<AppStatusBadge>`, the sidebar, the
+ * TitleBar, and the Add Apps dialog. Keep GA implicit; only call out alpha /
+ * beta. To promote an app from beta → GA, remove the `status` field from its
+ * entry (see the `set-product-status` skill).
+ */
+declare type AppStatus = 'alpha' | 'beta';
+
+export declare function AppStatusBadge({ status, className }: AppStatusBadgeProps): JSX.Element;
+
+declare interface AppStatusBadgeProps {
+    status: AppStatus;
+    className?: string;
+}
+
+/**
+ * Button that reflects the lifecycle of an async mutation:
+ * idle → pending (spinner) → success/error (auto-resets).
+ *
+ * Designed to pair with TanStack Query's `useMutation` return values.
+ */
+export declare function AsyncActionButton({ onClick, isPending, isSuccess, isError, error, icon, label, pendingLabel, successLabel, successTimeout, errorTimeout, className, }: AsyncActionButtonProps): JSX.Element;
+
+export declare interface AsyncActionButtonProps {
+    onClick: () => void;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error?: Error | null;
+    icon: React.ReactNode;
+    label: string;
+    pendingLabel: string;
+    /** Label shown on success. Defaults to "Triggered". */
+    successLabel?: string;
+    /** How long to show the success state before resetting (ms). */
+    successTimeout?: number;
+    /** How long to show the error state before resetting (ms). */
+    errorTimeout?: number;
+    className?: string;
+}
+
+export declare function AvatarTextCell({ icon, initials, title, subtitle, tag, tint, rightSlot, className, }: AvatarTextCellProps): JSX.Element;
+
+declare interface AvatarTextCellProps {
+    /** Icon rendered inside the tinted square. */
+    icon?: React_2.ReactNode;
+    /** Fallback initials when no icon is supplied. */
+    initials?: string;
+    title: React_2.ReactNode;
+    subtitle?: React_2.ReactNode;
+    /** Small mono tag rendered inline to the right of the title (e.g. "Sonnet 4.5"). */
+    tag?: React_2.ReactNode;
+    tint?: AgentTint;
+    /** Override inline action rendered on hover at the right of the title row. */
+    rightSlot?: React_2.ReactNode;
+    className?: string;
+}
+
+export declare const Badge: React_2.ForwardRefExoticComponent<BadgeProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+declare interface BadgeProps extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
+}
+
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "success" | "secondary" | "neutral" | "destructive" | "outline" | "warning" | "info" | "danger" | "identity" | "ghost" | "alpha" | "beta" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare function Breadcrumb({ items, interactive, maxItems, variant, renderLink, ariaLabel, className, }: BreadcrumbProps): JSX.Element | null;
+
+declare function Breadcrumb_2({ ...props }: React_2.ComponentProps<"nav">): JSX.Element;
+
+/**
+ * Breadcrumb — the app-facing, presentational breadcrumb.
+ *
+ * App-agnostic on purpose so it ships in the published `atlas-ui` package and
+ * artifacts can use it: it takes the full `items` trail as a prop and does NOT
+ * touch any app registry, router, or `next/navigation`. Navigation defaults to
+ * plain `<a href>`; inject `renderLink` (e.g. a SPA `Link`) for client routing,
+ * or mount `BreadcrumbLinkProvider` once to supply it to a whole subtree (the
+ * Atlas shell does this). For the app-root crumb, prepend `useAppRootCrumb()`
+ * (`@platform/hooks/useAppRootCrumb`).
+ *
+ * Depth drives the affordance (`variant='auto'`): 0 ancestors → nothing, 1 →
+ * back button, 2+ → breadcrumb. Long trails collapse into an ellipsis dropdown
+ * (`maxItems`); every crumb truncates with a tooltip; `loading` crumbs show a
+ * pulsing skeleton.
+ */
+export declare interface BreadcrumbCrumb {
+    label: React_2.ReactNode;
+    /** Navigation target for an ancestor crumb. Ignored on the last crumb (it
+     *  renders as the current page). Prefer `href`; use `onClick` for custom nav. */
+    href?: string;
+    onClick?: () => void;
+    /** Render a pulsing skeleton in place of the label while its value loads. */
+    loading?: boolean;
+}
+
+declare function BreadcrumbEllipsis({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
+
+declare function BreadcrumbItem({ className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
+
+declare function BreadcrumbLink({ asChild, className, ...props }: React_2.ComponentProps<"a"> & {
+    asChild?: boolean;
+}): JSX.Element;
+
+/**
+ * Supplies the router link that `Breadcrumb` uses for ancestor crumbs. Mount it
+ * once in the app shell with your SPA `Link` so every breadcrumb navigates
+ * client-side; without it (e.g. in a standalone artifact) breadcrumbs fall back
+ * to plain `<a href>`. A `renderLink` prop on an individual `Breadcrumb` still
+ * wins over this.
+ */
+export declare function BreadcrumbLinkProvider({ renderLink, children, }: {
+    renderLink: BreadcrumbLinkRenderer;
+    children: React_2.ReactNode;
+}): JSX.Element;
+
+/** Renders a navigable crumb. Default is a plain `<a href>`; a host injects its
+ *  router link (e.g. `<Link to={href}>`) so SPA nav works without coupling the
+ *  shared component to any router. */
+export declare type BreadcrumbLinkRenderer = (props: {
+    href: string;
+    onClick?: () => void;
+    className?: string;
+    children: React_2.ReactNode;
+}) => React_2.ReactElement;
+
+declare function BreadcrumbList({ className, ...props }: React_2.ComponentProps<"ol">): JSX.Element;
+
+declare function BreadcrumbPage({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
+
+/**
+ * shadcn breadcrumb primitives, grouped under one namespace so the bare name
+ * `Breadcrumb` names the app-facing smart component (`./breadcrumb-nav`).
+ * Compose these directly only when building a bespoke trail; almost all code
+ * should use the smart `Breadcrumb` instead.
+ */
+export declare const BreadcrumbPrimitive: {
+    Root: typeof Breadcrumb_2;
+    List: typeof BreadcrumbList;
+    Item: typeof BreadcrumbItem;
+    Link: typeof BreadcrumbLink;
+    Page: typeof BreadcrumbPage;
+    Separator: typeof BreadcrumbSeparator;
+    Ellipsis: typeof BreadcrumbEllipsis;
+};
+
+export declare interface BreadcrumbProps {
+    /** The full trail; the last item renders as the current page. */
+    items: BreadcrumbCrumb[];
+    /** When false, ancestor crumbs render as static text (e.g. loading states). */
+    interactive?: boolean;
+    /** Collapse the middle of long trails to an ellipsis-dropdown once the count
+     *  exceeds this (clamped to >= 2 so the root + current page always show). */
+    maxItems?: number;
+    /**
+     * Which affordance to render. Defaults to `'auto'`, which picks by depth so
+     * callers never decide: **0 ancestors** → nothing; **1 ancestor** → a back
+     * button (a full breadcrumb is overkill one level deep); **2+ ancestors** →
+     * the breadcrumb trail. Force `'breadcrumb'` / `'back'` for a deliberate
+     * exception.
+     */
+    variant?: "auto" | "breadcrumb" | "back";
+    /** Injected router link. Defaults to a plain `<a href>`. */
+    renderLink?: BreadcrumbLinkRenderer;
+    ariaLabel?: string;
+    className?: string;
+}
+
+declare function BreadcrumbSeparator({ children, className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
+
+/**
+ * Generate heat-colored columns for time-period keys (dates, weeks, months).
+ * Each column auto-computes min/max from visible rows for relative coloring.
+ */
+export declare function buildPeriodColumns<T extends Record<string, any>>({ periods, accessor, formatLabel, formatValue, }: {
+    periods: string[];
+    accessor: (row: T) => Record<string, number>;
+    formatLabel: (period: string) => string;
+    /** Custom value formatter. Defaults to whole-dollar currency. */
+    formatValue?: (value: number) => string;
+}): ColumnDef<T>[];
+
+/**
+ * A "Total" column with a value + horizontal progress bar.
+ */
+export declare function buildTotalColumn<T>({ accessor, maxValue, formatValue, barColor, }: {
+    accessor: (row: T) => number;
+    maxValue: number;
+    formatValue?: (value: number) => string;
+    barColor?: string;
+}): ColumnDef<T>;
+
+export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+
+export declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost" | "submit" | null | undefined;
+    size?: "default" | "sm" | "icon" | "lg" | "xs" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare function Calendar({ className, classNames, showOutsideDays, ...props }: React_2.ComponentProps<typeof DayPicker>): JSX.Element;
+
+export declare function CalendarGrid({ startHour, endHour, hourHeight, maxHeight, initialScrollHour, dayHeaders, children, loading, loadingText, }: CalendarGridProps): JSX.Element;
+
+export declare interface CalendarGridProps {
+    startHour?: number;
+    endHour?: number;
+    hourHeight?: number;
+    maxHeight?: number;
+    initialScrollHour?: number;
+    dayHeaders?: default_2.ReactNode[];
+    children: (dayIdx: number) => default_2.ReactNode;
+    loading?: boolean;
+    loadingText?: string;
+}
+
+/**
+ * Card — the foundational surface for grouped content (dashboards,
+ * metrics, forms, lists, detail pages).
+ *
+ * Visual contract:
+ *   - Background: `bg-card`, which maps to the `--card` design token.
+ *     `--card` is pure white (`oklch(1 0 0)`) in every Atlas app theme
+ *     — verified in `atlas/src/index.css`. Dark mode resolves to the
+ *     warm-dark surface token. Do NOT hardcode `bg-white` / `#fff`:
+ *     the theme system needs the variable to switch modes reliably.
+ *   - Text: `text-card-foreground` — paired with `--card` so reversed
+ *     themes flip body color correctly.
+ *   - Separation: a 1px `border` (maps to `--border`), NOT a drop
+ *     shadow. Matches the flat aesthetic used by ProDataTable,
+ *     DashboardShell, Input, Select, Textarea, Switch, and Button.
+ *     Drop shadows on cards quickly compound against each other in
+ *     dense dashboards (card-inside-card, kpi-tile-inside-card, etc.)
+ *     and visually muddy the hierarchy.
+ *   - Radius: `rounded-surface` (DES-313) — the top-level-container
+ *     radius role. Cards own their radius; call sites never pass one.
+ *
+ * When a card genuinely needs elevation (modal/popover-adjacent lifts,
+ * drag affordances), opt in explicitly with `shadow-resting`
+ * at the call site rather than baking it into the base.
+ */
+export declare const Card: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type ChartConfig = {
+    [key: string]: {
+        label?: React_2.ReactNode;
+        icon?: React_2.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+
+export declare function ChartContainer({ id, className, children, config, ...props }: React_2.ComponentProps<'div'> & {
+    config: ChartConfig;
+    children: React_2.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
+}): JSX.Element;
+
+export declare const ChartLegend: typeof RechartsPrimitive.Legend;
+
+export declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: {
+    className?: string;
+    hideIcon?: boolean;
+    payload?: LegendPayloadItem[];
+    verticalAlign?: 'top' | 'bottom';
+    nameKey?: string;
+}): JSX.Element | null;
+
+export declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+
+export declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: {
+    active?: boolean;
+    payload?: TooltipPayloadItem[];
+    className?: string;
+    indicator?: 'line' | 'dot' | 'dashed';
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    label?: React_2.ReactNode;
+    labelFormatter?: (value: React_2.ReactNode, payload: TooltipPayloadItem[]) => React_2.ReactNode;
+    labelClassName?: string;
+    formatter?: (value: number | string, name: string | number, item: TooltipPayloadItem, index: number, payloadItem: Record<string, unknown> | undefined) => React_2.ReactNode;
+    color?: string;
+    nameKey?: string;
+    labelKey?: string;
+}): JSX.Element | null;
+
+/**
+ * Checkbox — matches shadcn's canonical 16×16 design:
+ *
+ *   - `size-4` (16px)
+ *   - `rounded-xs` (4px, `--radius-xs`) — a square with softened corners,
+ *     NOT a circle. Atlas's scale shifted `--radius-sm` up to 8px, which
+ *     would render a 16px checkbox as a 50% pill. `--radius-xs` closes
+ *     the gap at the tight end specifically for cases like this.
+ *   - Neutral `border-input` when unchecked; flips to `border-primary`
+ *     when checked/indeterminate so the outline blends with the fill.
+ *   - No drop shadow — consistent with the rest of Atlas's form
+ *     primitives (Input, Select, Button).
+ *   - Distinct icon for indeterminate state (horizontal minus) so a
+ *     bulk-select header reads as "some selected" without showing a
+ *     check mark. Switching is driven by Radix's `data-state` attribute
+ *     via Tailwind `group-data-*` modifiers — no extra state wiring.
+ *
+ * Composition safety: the Check + Minus icons each carry an explicit
+ * `text-current` class even though the Indicator parent already sets
+ * `text-current`. This is NOT redundant — it's the safeguard against
+ * descendant-svg dyeing rules like cmdk's
+ * `[&_svg:not([class*='text-'])]:text-muted-foreground` on CommandItem.
+ * The icons need their OWN `text-*` class on the svg element so the
+ * `:not([class*='text-'])` filter doesn't match them. See DESIGN.md
+ * "Composition safety" and `controls:compositions` in the Design System.
+ */
+export declare const Checkbox: React_2.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * A crisp multi-select rendered as toggleable option cards — a nicer stand-in
+ * for a grid of native checkboxes. Reusable for any small set of multi-choice
+ * options (review areas, tags, scopes, …).
+ */
+export declare function CheckboxGroup<T extends string>({ options, value, onChange, columns, className, }: CheckboxGroupProps<T>): JSX.Element;
+
+export declare interface CheckboxGroupProps<T extends string> {
+    options: CheckboxOption<T>[];
+    value: T[];
+    onChange: (next: T[]) => void;
+    columns?: 1 | 2 | 3;
+    className?: string;
+}
+
+export declare interface CheckboxOption<T extends string> {
+    value: T;
+    label: string;
+}
+
+declare const CHIP_TONES: {
+    readonly default: "border-border bg-accent text-muted-foreground";
+    readonly danger: "border-red-200 bg-red-50 text-red-700 dark:border-red-500/30 dark:bg-red-500/15 dark:text-red-300";
+    readonly warning: "border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-500/30 dark:bg-amber-500/15 dark:text-amber-300";
+    readonly success: "border-emerald-200 bg-emerald-50 text-emerald-700 dark:border-emerald-500/30 dark:bg-emerald-500/15 dark:text-emerald-300";
+};
+
+export declare const ChoiceCard: React_2.ForwardRefExoticComponent<ChoiceCardProps & React_2.RefAttributes<HTMLLabelElement>>;
+
+/**
+ * ChoiceCardGroup — the canonical wrapper for a stack of `ChoiceCard`s.
+ *
+ * Differences from `FieldGroup`:
+ *   - Gap is `gap-2` (8px), not `gap-7` (28px). ChoiceCards are visually
+ *     dense already (border + padding + hover); a tight gap reads as a
+ *     single group rather than a loose collection of unrelated rows.
+ *   - Optional `searchable` — adds a search input that filters children
+ *     by their `searchTerms` prop (with text fallbacks). Useful when the
+ *     underlying list is long (tool palettes, integrations, etc.).
+ *
+ * Children are expected to be `<ChoiceCard>` elements. Non-ChoiceCard
+ * children pass through unchanged and aren't affected by the filter —
+ * so you can intermix dividers, section headers, or `<FieldSeparator>`
+ * without them being stripped when the user types.
+ */
+export declare const ChoiceCardGroup: React_2.ForwardRefExoticComponent<ChoiceCardGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface ChoiceCardGroupProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    /**
+     * When true, renders a search input above the list that filters visible
+     * cards by matching the query against each card's `searchTerms` prop
+     * (or a fallback derived from the card's `title` / `description`).
+     * Intended for long lists — tool pickers, skill palettes, integration
+     * catalogs — where users need to narrow down quickly.
+     */
+    searchable?: boolean;
+    /** Placeholder shown in the search input. Defaults to `'Search'`. */
+    searchPlaceholder?: string;
+    /**
+     * Rendered when the search query matches zero cards. Defaults to a
+     * muted "No matches" row. Pass a richer ReactNode (illustration, CTA,
+     * etc.) when context warrants it.
+     */
+    emptyState?: React_2.ReactNode;
+    children?: React_2.ReactNode;
+}
+
+/**
+ * ChoiceCard — card-style selection row built on shadcn's `Field` family.
+ *
+ * Composes `FieldLabel` (which makes the whole card clickable as a native
+ * label) + `Field` (horizontal) + `FieldContent` (holding `FieldTitle` +
+ * `FieldDescription`) + `Switch`. This is the canonical "Switch Choice
+ * Card" pattern from shadcn — wrapping it here saves consumers from
+ * hand-assembling the five Field primitives every time and ensures the
+ * shared selected-tint behavior (`has-data-[state=checked]:bg-primary/5`)
+ * kicks in consistently.
+ *
+ * Composition:
+ * ```tsx
+ * import { ChoiceCard, ChoiceCardGroup } from '@sequenceholdings/atlas-ui'
+ *
+ * <ChoiceCardGroup>
+ *   <ChoiceCard
+ *     title="Web search"
+ *     description="General web lookup via platform search provider"
+ *     checked={enabled}
+ *     onCheckedChange={setEnabled}
+ *   />
+ * </ChoiceCardGroup>
+ * ```
+ *
+ * `ChoiceCardGroup` is the recommended wrapper — it renders choice cards
+ * at a tighter 8px gap (vs `FieldGroup`'s 28px) and supports an optional
+ * search input for long lists. `FieldGroup` remains available for mixed
+ * Field layouts where the looser spacing is intentional.
+ *
+ * When you need extra content below the description (e.g. a secondary
+ * checkbox, a config chip, a status indicator), pass it via `children` —
+ * it renders inside `FieldContent` after the description.
+ *
+ * When you need a different trailing control (Checkbox, Radio, icon
+ * button), pass it via `control`; otherwise the default `Switch` is used.
+ * Controls receive their own `onClick` handlers and don't need propagation
+ * handling — the label wiring covers row clicks.
+ */
+declare interface ChoiceCardProps {
+    /**
+     * Leading icon slot — renders as a tinted 32px square tile on the left
+     * of the card. Accepts a lucide/tabler icon; the tile styling and sizing
+     * are handled here so callers just pass the glyph.
+     */
+    icon?: React_2.ReactNode;
+    /**
+     * Primary label — renders inside `FieldTitle`. Accepts a ReactNode so
+     * inline badges / tags can sit next to the title.
+     */
+    title: React_2.ReactNode;
+    /** Secondary text — renders inside `FieldDescription`. */
+    description?: React_2.ReactNode;
+    /**
+     * Default trailing control is a `Switch`. Pass a custom control here
+     * to use something else (Checkbox, Radio, icon button). The custom
+     * control is responsible for its own state — `checked` /
+     * `onCheckedChange` are ignored when `control` is set.
+     */
+    control?: React_2.ReactNode;
+    /** Forwarded to the default `Switch`. */
+    checked?: boolean;
+    /** Forwarded to the default `Switch`. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Forwarded to the default `Switch` — also surfaces Field's disabled styling. */
+    disabled?: boolean;
+    /**
+     * Optional id. When omitted, one is generated so the FieldLabel's
+     * `htmlFor` binds to the Switch automatically. Override only when the
+     * consumer needs to reference the control id externally.
+     */
+    id?: string;
+    /**
+     * Canonical searchable text used by `ChoiceCardGroup` when `searchable`
+     * is enabled. Lets callers control exactly what a query matches against
+     * — important when `title` / `description` are ReactNodes (badges,
+     * icons, fragments) that can't be reliably stringified.
+     *
+     * When omitted, the group falls back to stringifying whatever string
+     * content it can extract from `title` and `description`; works fine for
+     * plain-text cards, unreliable for rich ones. Provide it explicitly
+     * for any list where search matters.
+     */
+    searchTerms?: string;
+    /** Additional content rendered inside FieldContent after the description. */
+    children?: React_2.ReactNode;
+    className?: string;
+}
+
+export declare function CitationChip({ fileName, url, kind, resolved, className, }: CitationChipProps): JSX.Element;
+
+/**
+ * Inline citation chip — the rendered form of a resolved `[[cite:...]]` anchor.
+ * A `document` chip shows the source filename; a `web` chip shows the site (or
+ * host) and links out; an unresolved anchor renders a muted "source" pill so a
+ * fabricated/dropped citation is still visible rather than a raw token.
+ *
+ * The label truncates and reveals its full value on hover (via `TruncatedText`).
+ * When a `url` is present the chip is an anchor that opens in a new tab.
+ */
+export declare interface CitationChipProps {
+    fileName?: string | null;
+    url?: string | null;
+    kind?: 'web' | 'document';
+    /** False renders the muted unresolved state. Defaults to true. */
+    resolved?: boolean;
+    className?: string;
+}
+
+export declare function cn(...inputs: ClassValue[]): string;
+
+export declare const CodeBadge: React_2.ForwardRefExoticComponent<CodeBadgeProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+declare interface CodeBadgeProps extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof codeBadgeVariants> {
+}
+
+/**
+ * CodeBadge — small inline monospace pill for literal strings.
+ *
+ * Use for identifiers that read as "code" rather than prose: model IDs
+ * (`gemini-3.1-flash-lite-preview`), version labels (`v14`), commit hashes,
+ * cron expressions, IDs, etc. Sits naturally next to titles, inside table
+ * cells, or in top-bar identity rows.
+ *
+ * When to reach for this vs. `Badge`:
+ *   - `Badge` — semantic status/tone (success, destructive, outline)
+ *   - `CodeBadge` — typographic tag (monospace, muted bg, neutral)
+ *
+ * Sizes:
+ *   - `sm` (default) — inline next to a title (e.g. AvatarTextCell tag)
+ *   - `md` — inside table cells where it reads as primary content
+ */
+export declare const codeBadgeVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+/**
+ * Table-cell wrapper around `CodeBadge` for columns that render literal
+ * strings (version labels, cron expressions, IDs). Kept as a separate export
+ * so column definitions can stay value-oriented (`<CodePillCell value={v} />`)
+ * rather than wrapping children — but the visual treatment now lives in
+ * the shared `CodeBadge` primitive.
+ */
+export declare function CodePillCell({ value, className, }: {
+    value: React_2.ReactNode;
+    className?: string;
+}): JSX.Element;
+
+export { ColumnDef }
+
+export declare function Command({ className, ...props }: React_2.ComponentProps<typeof Command_2>): JSX.Element;
+
+export declare function CommandDialog({ title, description, children, className, ...props }: React_2.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+}): JSX.Element;
+
+export declare function CommandEmpty({ ...props }: React_2.ComponentProps<typeof Command_2.Empty>): JSX.Element;
+
+export declare function CommandGroup({ className, ...props }: React_2.ComponentProps<typeof Command_2.Group>): JSX.Element;
+
+export declare function CommandInput({ className, showSearchIcon, ...props }: React_2.ComponentProps<typeof Command_2.Input> & {
+    showSearchIcon?: boolean;
+}): JSX.Element;
+
+export declare function CommandItem({ className, ...props }: React_2.ComponentProps<typeof Command_2.Item>): JSX.Element;
+
+export declare function CommandList({ className, ...props }: React_2.ComponentProps<typeof Command_2.List>): JSX.Element;
+
+export declare function CommandSeparator({ className, ...props }: React_2.ComponentProps<typeof Command_2.Separator>): JSX.Element;
+
+export declare function CommandShortcut({ className, ...props }: React_2.ComponentProps<'span'>): JSX.Element;
+
+/**
+ * In-app confirmation dialog — a thin convenience over the AlertDialog
+ * primitives for the common confirm-before-action flow (deletes, destructive
+ * edits).
+ *
+ * Prefer this over `window.confirm`: in a sandboxed Artifact Studio iframe the
+ * native dialog is blocked (no `allow-modals`) and silently returns false, so a
+ * "delete" button wired to `confirm()` appears to do nothing.
+ */
+export declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel, cancelLabel, destructive, onConfirm, }: ConfirmDialogProps): JSX.Element;
+
+export declare interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Render the confirm action with destructive styling (red). */
+    destructive?: boolean;
+    onConfirm: () => void;
+}
+
+/**
+ * Full content-area loading indicator. Use when an entire tab or page section
+ * is waiting for data. Renders a centered large spinner with a consistent
+ * fade-in animation so loading → content transitions feel smooth.
+ */
+export declare function ContentLoadingState({ className }: ContentLoadingStateProps): JSX.Element;
+
+export declare interface ContentLoadingStateProps {
+    className?: string;
+}
+
+export declare const ContextMenu: React_2.FC<ContextMenuPrimitive.ContextMenuProps>;
+
+export declare const ContextMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuContent: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuGroup: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuLabel: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuPortal: React_2.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+
+export declare const ContextMenuRadioGroup: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuSeparator: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuShortcut: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const ContextMenuSub: React_2.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+
+export declare const ContextMenuSubContent: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuTrigger: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare function DashboardShell({ title, range, actions, children, className, bodyClassName, }: DashboardShellProps): JSX.Element;
+
+/**
+ * DashboardShell — canonical frame for dashboard / list pages.
+ *
+ * Provides the compact 12-row top bar (title · range slot · actions slot) and
+ * a scrolling body with consistent horizontal/vertical rhythm. Pages compose
+ * their content (KPI strip, chart cards, tables) as direct children — each
+ * child gets `gap-5` vertical spacing automatically.
+ *
+ * Scrolling ownership: the body is the *only* vertical scroll container for
+ * the page. Do NOT wrap `<DashboardShell>` in another `overflow-y-auto` div.
+ * Height flows from the platform app shell (`atlas-shell-routes` → app
+ * wrapper → `h-full`).
+ *
+ * Composition:
+ * ```tsx
+ * <DashboardShell
+ *   title="Agents"
+ *   range={<SegmentedControl value="24h" onChange={…} options={…} />}
+ *   actions={<>
+ *     <Button variant="outline" size="sm">Import</Button>
+ *     <Button size="sm">New agent</Button>
+ *   </>}
+ * >
+ *   <KpiTileGrid columns={4}>…</KpiTileGrid>
+ *   <ChartCard />
+ *   <ProDataTable … />
+ * </DashboardShell>
+ * ```
+ *
+ * Rules:
+ * - Don't render a page subtitle (e.g. "N total") under the title — those
+ *   belong in section headers or on the table itself.
+ * - Don't nest a `<DashboardShell>` inside another scroll container.
+ * - Title renders at 16px (`text-base`).
+ */
+declare interface DashboardShellProps {
+    /** Page title — 16px, semibold. Usually a short noun ("Agents", "Schedules"). */
+    title: ReactNode;
+    /** Small controls rendered left of the actions (e.g. 24h/7d/30d toggle). */
+    range?: ReactNode;
+    /** Right-aligned action buttons (Import, New item, etc.). */
+    actions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    /** Extra className on the scrolling body. Use for custom gap/padding overrides. */
+    bodyClassName?: string;
+}
+
+export declare function DataTable<T>({ columns, data, pageSize, defaultSort, emptyMessage, onRowClick, rowClassName, className, }: DataTableProps<T>): JSX.Element;
+
+declare interface DataTableProps<T> {
+    columns: ColumnDef<T, unknown>[];
+    data: T[];
+    pageSize?: number;
+    defaultSort?: SortingState;
+    emptyMessage?: string;
+    onRowClick?: (row: T) => void;
+    rowClassName?: (row: Row<T>) => string | undefined;
+    className?: string;
+}
+
+/**
+ * Date picker working in `Date | null` (or `DateRange | null` in `mode="range"`).
+ * Radix popover + react-day-picker calendar + free-text parsing + presets.
+ *
+ * Most fields persist a date-only `YYYY-MM-DD` string — for those, reach for
+ * {@link IsoDateField} (single) or `DateRangePill` (start–end range) instead,
+ * which own the string ↔ Date bridge (local-midnight parse, invalid-date
+ * rejection) so you don't re-implement it. Use `DateField` directly only when
+ * the value is genuinely a `Date`/`DateRange`: an in-memory filter, a
+ * non-date-only serialization (e.g. a full timestamp), or a custom trigger.
+ *
+ * @see IsoDateField — single date-only string fields (the common case)
+ * @see DateRangePill — start–end ranges persisted as strings
+ */
+export declare function DateField(props: DateFieldProps): React_2.ReactElement;
+
+declare interface DateFieldCommonProps {
+    /** Optional id for the trigger control (enables `<label htmlFor>` association). */
+    id?: string;
+    /** Placeholder for the trigger when no value is set. */
+    placeholder?: string;
+    /** Disable both input and calendar. */
+    disabled?: boolean;
+    /** Latest date the user can pick / parse. Inclusive. */
+    max?: Date;
+    /** Earliest date the user can pick / parse. Inclusive. */
+    min?: Date;
+    /**
+     * Override "today" — both for relative phrase parsing AND for
+     * the default visible month on the calendar. Tests pass this to
+     * pin output; UI callers usually leave it undefined.
+     */
+    referenceDate?: Date;
+    /** Popover alignment relative to the trigger. */
+    align?: 'start' | 'center' | 'end';
+    /**
+     * Override the default preset list. Pass `[]` to hide presets
+     * entirely (yields a leaner popover for tight surfaces).
+     */
+    presets?: readonly DateFieldPreset[];
+    /** Extra classes applied to the trigger wrapper div. */
+    containerClassName?: string;
+    /** Extra classes applied to the trigger button. */
+    className?: string;
+    /** ARIA label for the trigger button. */
+    ariaLabel?: string;
+    /**
+     * When set, applies `aria-invalid` to the trigger button so validation
+     * helpers (e.g. scroll-to-first-error) can locate and focus this control.
+     */
+    'aria-invalid'?: boolean;
+    /** Render a clear (X) affordance inside the trigger when a value is set. */
+    clearable?: boolean;
+    /**
+     * Year-resolution direction for bare month / month-day text input
+     * (e.g. `"Jun 8"` with no year). Defaults to `'past'` — matches
+     * retrospective filter usage. Pass `'future'` on forward-planning
+     * surfaces (due dates, scheduling) so `"Jun 8"` in May reads as the
+     * upcoming June 8 instead of last year's.
+     */
+    yearBias?: YearBias;
+}
+
+/**
+ * A relative preset. The `value` is computed lazily against a
+ * reference date so the same preset table works in any mode and
+ * with any "now" — including the test/fixture case where callers
+ * pass `referenceDate` to make rendering deterministic.
+ */
+export declare interface DateFieldPreset {
+    label: string;
+    /**
+     * Resolve the preset against a reference date. Return either:
+     *   - a `Date` (the preset picks a single day),
+     *   - a `DateRange` (the preset picks a span),
+     *   - `null` to skip rendering (rare; lets callers gate presets
+     *     conditionally without removing them from the array).
+     *
+     * `DateField` automatically adapts: a preset that yields a range
+     * but is clicked in single mode falls back to the range's `from`
+     * day, and a preset that yields a single date in range mode is
+     * treated as `from === to`.
+     */
+    resolve: (now: Date) => Date | DateRange | null;
+}
+
+export declare type DateFieldProps = DateFieldSingleProps | DateFieldRangeProps;
+
+declare interface DateFieldRangeProps extends DateFieldCommonProps {
+    mode: 'range';
+    value: DateRange | null;
+    onChange: (next: DateRange | null) => void;
+}
+
+declare interface DateFieldSingleProps extends DateFieldCommonProps {
+    mode?: 'single';
+    value: Date | null;
+    onChange: (next: Date | null) => void;
+}
+
+export declare interface DateRange {
+    from: Date;
+    to: Date;
+}
+
+/** Checkbox "checked" target: clicking an unchecked row sets this. */
+export declare const DEFAULT_COMPLETE_STATUS = "done";
+
+/** Checkbox "unchecked" target: clicking a checked row resets to this. */
+export declare const DEFAULT_INCOMPLETE_STATUS = "todo";
+
+/** Default range presets — the canonical "filter by time" set. */
+export declare const DEFAULT_RANGE_PRESETS: readonly DateFieldPreset[];
+
+/** Statuses treated as resolved: title struck-through + due-date urgency suppressed. */
+export declare const DEFAULT_RESOLVED_STATUSES: readonly string[];
+
+/** Default single-date presets. */
+export declare const DEFAULT_SINGLE_PRESETS: readonly DateFieldPreset[];
+
+/** Hover "Start" button target, shown when a row sits at the incomplete status. */
+export declare const DEFAULT_START_STATUS = "in_progress";
+
+export declare const DEFAULT_STATUS_BOARD_ORDER: readonly string[];
+
+export declare const DEFAULT_STATUS_OPTIONS: TaskStatusOption[];
+
+/** The status values the built-in default vocabulary uses. */
+export declare type DefaultTaskStatus = 'todo' | 'in_progress' | 'blocked' | 'done' | 'cancelled';
+
+/**
+ * Dialog — modal dialog built on Radix's Dialog primitive.
+ *
+ * Composition (header + body + footer):
+ *
+ *   <Dialog>
+ *     <DialogTrigger asChild><Button>Open</Button></DialogTrigger>
+ *     <DialogContent>
+ *       <DialogHeader>
+ *         <DialogTitle>Title</DialogTitle>
+ *         <DialogDescription>Optional helper copy.</DialogDescription>
+ *       </DialogHeader>
+ *       <DialogBody>
+ *         {form fields / long content}
+ *       </DialogBody>
+ *       <DialogFooter>
+ *         <DialogClose asChild><Button variant="ghost">Cancel</Button></DialogClose>
+ *         <Button>Save</Button>
+ *       </DialogFooter>
+ *     </DialogContent>
+ *   </Dialog>
+ *
+ * Layout contract:
+ *   - `DialogContent` is a flex column with `overflow-hidden` — the
+ *     rounded corners clip the header/body/footer surfaces so they
+ *     meet the corners cleanly.
+ *   - `DialogHeader` is `shrink-0` on the shared white (`bg-card`)
+ *     surface with a 1px `border-b`. The border acts as the scroll
+ *     horizon — content in `DialogBody` slides under that line when
+ *     scrolled. No tint on the header: the dialog reads as one clean
+ *     white card with subtle dividers rather than stratified bands.
+ *   - `DialogBody` is `flex-1 min-h-0 overflow-y-auto` with its own
+ *     padding, same white surface as the header. Single scroll region
+ *     — content scrolls independently of the sticky header/footer.
+ *   - `DialogFooter` mirrors the header: white surface + 1px
+ *     `border-t` so the action row reads as a capped footer that
+ *     doesn't scroll with content.
+ *   - All three zones share `px-6 py-4` padding so the vertical
+ *     rhythm stays uniform; the borders are the only visual
+ *     differentiator.
+ *
+ * Atlas-specific behaviors:
+ *   - Portal mounts into the shared Atlas portal container
+ *     (`usePortalContainer()`), so dialogs trap focus + stacking
+ *     correctly inside MFEs (chat-admin, inbox, agents) that isolate
+ *     their own DOM scope.
+ *   - Fallback portal root is appended under `document.body` (NOT
+ *     `documentElement`) — a portal on `<html>` breaks Radix's
+ *     `aria-hidden` bookkeeping for nested layers.
+ *   - Title renders at `text-base` (16px) semibold — NOT `text-lg`
+ *     (which in Atlas's token scale is 26px / hero size).
+ *   - Overlay is `bg-overlay` with a light backdrop blur — a
+ *     mode-independent dark scrim, NOT an alpha of `--foreground`
+ *     (see `DialogOverlay`).
+ *   - Content rounds to `rounded-surface` (DES-313) — the top-level
+ *     container radius role shared with Card.
+ */
+export declare const Dialog: React_2.FC<DialogPrimitive.DialogProps>;
+
+/**
+ * DialogBody — the scrollable body region between DialogHeader and
+ * DialogFooter. New in this revision.
+ *
+ * Use this for any dialog with form fields, long content, or anything
+ * that might exceed the viewport. For very short dialogs where the
+ * scroll affordance is overkill, consumers can still render their own
+ * `<div>` between header and footer; this component just encodes the
+ * standard pattern (flex-1 + min-h-0 + overflow-y-auto + default
+ * padding) so callers don't have to remember the details.
+ */
+export declare function DialogBody({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+export declare namespace DialogBody {
+    var displayName: string;
+}
+
+export declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const DialogContent: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    /**
+     * Render the corner close affordance. Default `true`. Set `false` to
+     * suppress it during a blocking in-dialog action (e.g. an upload in
+     * flight) so the user can't dismiss mid-operation. Pair with a
+     * controlled `open` + an `onOpenChange` guard for full lockout.
+     */
+    showCloseButton?: boolean;
+    /**
+     * Classes for the scrim behind the dialog. Pair with `className` when
+     * raising z-index — a lone `className="z-modal"` lifts only the panel and
+     * leaves the overlay at `z-50` (DES-315). Additive; defaults unchanged.
+     */
+    overlayClassName?: string;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare function DialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+export declare namespace DialogFooter {
+    var displayName: string;
+}
+
+export declare function DialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+export declare namespace DialogHeader {
+    var displayName: string;
+}
+
+export declare const DialogOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare function DialogPortal({ container, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Portal>): JSX.Element;
+
+export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const DropdownMenu: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+
+export declare const DropdownMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+
+export declare const DropdownMenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+    displayName: string;
+};
+
+/**
+ * Nested submenu. **House convention:** when a `…` overflow menu offers a
+ * *choice among values* (role / permission / status / assignee), put the
+ * options in a `DropdownMenuSub` whose trigger is the field name — e.g.
+ * `Role ›` opens `Viewer ✓ / Admin` — instead of a flat label followed by the
+ * options inline. Keep standalone/destructive actions (`Remove access`) at the
+ * top level, and mark the current value with a right-aligned `Check`. This
+ * keeps the top menu short and scales as options grow.
+ *
+ * Reference: `PrincipalRow` / `GroupMembersDetail` role menus. See also
+ * `.cursor/rules/design-system.md` ("Overflow menus: nest the option list").
+ */
+export declare const DropdownMenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+
+export declare const DropdownMenuSubContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare function EditorPageHeader({ title, description, actions, className }: EditorPageHeaderProps): JSX.Element;
+
+/**
+ * EditorPageHeader — section title + description block used at the top of
+ * each editor pane (Prompt, Tools, Input Schema, etc.).
+ *
+ * Replaces the older `<Panel>` Card-wrap pattern with a flat layout that
+ * matches the new editor design. Title is 18px (one step up from the
+ * dashboard's 16px page header), description is 13px secondary text.
+ *
+ * Pair with `EditorSection` for vertically-stacked content blocks under the
+ * header — gives consistent spacing and an optional sub-section divider.
+ *
+ * Usage:
+ *   <EditorPagePane>
+ *     <EditorPageHeader
+ *       title="Prompt"
+ *       description="The system prompt sent to the model on every run …"
+ *     />
+ *     <EditorSection>…</EditorSection>
+ *     <EditorSection title="Model parameters">…</EditorSection>
+ *   </EditorPagePane>
+ */
+declare interface EditorPageHeaderProps {
+    title: React_2.ReactNode;
+    description?: React_2.ReactNode;
+    /** Right-aligned action(s) on the same row as the title. */
+    actions?: React_2.ReactNode;
+    className?: string;
+}
+
+export declare const EditorPagePane: React_2.ForwardRefExoticComponent<EditorPagePaneProps & React_2.RefAttributes<HTMLDivElement>>;
+
+declare interface EditorPagePaneProps extends React_2.HTMLAttributes<HTMLDivElement> {
+}
+
+export declare const EditorSection: React_2.ForwardRefExoticComponent<EditorSectionProps & React_2.RefAttributes<HTMLDivElement>>;
+
+declare interface EditorSectionProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Subtle section heading rendered above the content (smaller than EditorPageHeader). */
+    title?: React_2.ReactNode;
+    description?: React_2.ReactNode;
+    /** Right-aligned action(s) on the heading row. */
+    actions?: React_2.ReactNode;
+}
+
+export declare const EditorSideNav: React_2.ForwardRefExoticComponent<EditorSideNavProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare function EditorSideNavGroup({ label, headerTrailing, className, children, }: EditorSideNavGroupProps): JSX.Element;
+
+declare interface EditorSideNavGroupProps {
+    label?: React_2.ReactNode;
+    headerTrailing?: React_2.ReactNode;
+    className?: string;
+    children?: React_2.ReactNode;
+}
+
+export declare const EditorSideNavItem: React_2.ForwardRefExoticComponent<EditorSideNavItemProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface EditorSideNavItemProps extends React_2.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> {
+    /** Optional small right-aligned count or tag. */
+    trailing?: React_2.ReactNode;
+}
+
+/**
+ * EditorSideNav — vertical, grouped tab list for entity editors.
+ *
+ * Designed to drop in as the `<TabsList>` for a Radix `<Tabs orientation="vertical">`
+ * tree, so it works with the existing `<TabsContent value="…">` pattern with
+ * zero state plumbing. Visual goals:
+ *   - 220px wide rail with subtle right border
+ *   - Section headers (`EditorSideNavGroup`) use uppercase 11px tracking — same
+ *     density as the V2 dashboards' KPI labels
+ *   - Items are 28–30px tall with a soft fill on the active row
+ *
+ * Optional `header` / `footer` slots render INSIDE the rail's chrome but
+ * OUTSIDE the Radix tablist, so non-tab controls (brand row, freshness
+ * indicator, scope toggles) don't pollute the tablist's keyboard
+ * semantics or screen-reader announcements. Without these slots, mixing
+ * a `<button>` into the EditorSideNav children would put an interactive
+ * non-tab control inside `role=tablist`, breaking arrow-key navigation.
+ *
+ * Usage:
+ *   <Tabs orientation="vertical" defaultValue="overview" className="flex …">
+ *     <EditorSideNav
+ *       header={<BrandRow />}
+ *       footer={<LiveBadge />}
+ *     >
+ *       <EditorSideNavGroup label="General">
+ *         <EditorSideNavItem value="overview">Overview</EditorSideNavItem>
+ *         <EditorSideNavItem value="prompt">Prompt</EditorSideNavItem>
+ *       </EditorSideNavGroup>
+ *       …
+ *     </EditorSideNav>
+ *     <div>
+ *       <TabsContent value="overview">…</TabsContent>
+ *     </div>
+ *   </Tabs>
+ */
+declare interface EditorSideNavProps extends React_2.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+    /** Width override in px. Defaults to 220. */
+    width?: number;
+    /**
+     * Content rendered above the tablist — brand row, identity, etc.
+     * Lives outside the Radix tablist so it doesn't appear in keyboard /
+     * screen-reader navigation as a tab. Receives the same horizontal
+     * padding as the rail.
+     */
+    header?: React_2.ReactNode;
+    /**
+     * Content rendered below the tablist and pinned to the bottom of
+     * the rail (via `mt-auto`). Use for global controls and indicators
+     * (scope toggles, data-freshness badges) — anything that's
+     * interactive but not a tab. Lives outside the Radix tablist for
+     * the same accessibility reason as `header`.
+     */
+    footer?: React_2.ReactNode;
+}
+
+export declare const EditorTopBar: React_2.ForwardRefExoticComponent<EditorTopBarProps & React_2.RefAttributes<HTMLDivElement>>;
+
+/** Right-aligned action group. Adds spacing + flex-end positioning. */
+export declare function EditorTopBarActions({ className, children, }: {
+    className?: string;
+    children?: React_2.ReactNode;
+}): JSX.Element;
+
+export declare function EditorTopBarBackButton({ onClick, title }: {
+    onClick: () => void;
+    title?: string;
+}): JSX.Element;
+
+export declare function EditorTopBarIdentity({ icon, iconBg, iconColor, name, tag, badge, meta, className, }: EditorTopBarIdentityProps): JSX.Element;
+
+declare interface EditorTopBarIdentityProps {
+    /** Tinted square icon/avatar (28px) — pass an icon or initials. */
+    icon?: React_2.ReactNode;
+    /** Background color for the icon tile. */
+    iconBg?: string;
+    /** Foreground color for the icon glyph/initials. */
+    iconColor?: string;
+    /** Primary name. */
+    name: React_2.ReactNode;
+    /** Optional inline mono tag rendered next to the name (e.g. "Sonnet 4.5"). */
+    tag?: React_2.ReactNode;
+    /** Optional status badge rendered to the right of the tag. */
+    badge?: React_2.ReactNode;
+    /** Subtle meta line under the name (e.g. "Draft · edited 4m ago by …"). */
+    meta?: React_2.ReactNode;
+    className?: string;
+}
+
+/**
+ * EditorTopBar — minimal page header for entity editors (Agent, Workflow,
+ * Skill, etc.). Pairs with `EditorSideNav` + `EditorPageHeader` to form the
+ * standard editor chrome.
+ *
+ * Composition (left → right):
+ *   <EditorTopBar onBack={...}>                             ← back button slot
+ *     <EditorTopBarIdentity icon={...} name="…" tag="…" />  ← identity block
+ *     <EditorTopBarActions>                                 ← right side
+ *       ...buttons...
+ *     </EditorTopBarActions>
+ *   </EditorTopBar>
+ *
+ * Density matches the V2 dashboard top bars (52px tall) so editors and
+ * dashboards share a consistent shell row.
+ */
+declare interface EditorTopBarProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    onBack?: () => void;
+    /** Override the back button entirely (e.g. wrap in a Link). */
+    backSlot?: React_2.ReactNode;
+}
+
+/**
+ * Convenience status pill for "Draft / Deployed / Archived" etc. — uses the
+ * same dot+label aesthetic as `StatusDotBadge` but smaller for inline use
+ * inside the top bar identity block.
+ */
+export declare function EditorTopBarStatusBadge({ tone, label, }: {
+    tone?: 'success' | 'neutral' | 'warn' | 'info';
+    label: React_2.ReactNode;
+}): JSX.Element;
+
+/**
+ * Consistent empty-state placeholder for tables and content areas.
+ */
+export declare function EmptyState({ icon, message, detail, className }: EmptyStateProps): JSX.Element;
+
+export declare interface EmptyStateProps {
+    icon?: React.ReactNode;
+    message: string;
+    detail?: string;
+    className?: string;
+}
+
+/**
+ * The canonical inline failure banner — one treatment for "this panel could not
+ * load", used across apps so a failure reads the same everywhere.
+ *
+ * The red hue is fixed on purpose: it carries meaning, not theme. What it does
+ * carry is a dark pair — the `-50`/`-200`/`-700` triplet is tuned for a white
+ * surface and goes near-illegible on a dark one, so `.dark` lifts the fill to a
+ * translucent step and lightens the ink. Light is byte-identical.
+ */
+export declare function ErrorState({ message, className }: ErrorStateProps): JSX.Element;
+
+declare interface ErrorStateProps {
+    message: string;
+    className?: string;
+}
+
+/**
+ * The row-match test behind both facet predicates (multi + single), factored
+ * out as a pure function so the filtering behavior is unit-testable without
+ * driving the cmdk menu. A row is kept when:
+ *   - no filter is set (`undefined`/`''`/empty array), or
+ *   - `filterValue` is an array (multi) and the cell value is in it, or
+ *   - `filterValue` is a string (single) and the cell value equals it.
+ * The cell value is compared via {@link facetValueToString}, so numbers,
+ * booleans, and dates match the option `value` strings the facet offers.
+ */
+export declare function facetFilterMatches(cellValue: unknown, filterValue: string | string[] | undefined): boolean;
+
+export declare function Field({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>): JSX.Element;
+
+/** The display text for a field's auto-rendered chip. */
+export declare function fieldChipText(field: TaskFieldDef): string;
+
+export declare function FieldContent({ className, ...props }: React.ComponentProps<"div">): JSX.Element;
+
+export declare function FieldDescription({ className, ...props }: React.ComponentProps<"p">): JSX.Element;
+
+/** The current single-select value for a field's inline editor. */
+export declare function fieldEditorValue(field: TaskFieldDef): string | null;
+
+export declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<"div"> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): JSX.Element | null;
+
+export declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): JSX.Element;
+
+export declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): JSX.Element;
+
+export declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<"legend"> & {
+    variant?: "legend" | "label";
+}): JSX.Element;
+
+export declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<"div"> & {
+    children?: React.ReactNode;
+}): JSX.Element;
+
+export declare function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">): JSX.Element;
+
+export declare function FieldTitle({ className, ...props }: React.ComponentProps<"div">): JSX.Element;
+
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const FileDropzone: React_2.ForwardRefExoticComponent<FileDropzoneProps & React_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Companion component — renders the current file selection as a list
+ * with per-item remove buttons. Separate from `FileDropzone` on
+ * purpose: some layouts want the list above the dropzone, some below,
+ * some inside a dialog. The dropzone emits the file array; callers
+ * render however they want.
+ */
+export declare const FileDropzoneList: React_2.ForwardRefExoticComponent<FileDropzoneListProps & React_2.RefAttributes<HTMLUListElement>>;
+
+export declare interface FileDropzoneListProps extends React_2.HTMLAttributes<HTMLUListElement> {
+    files: File[];
+    onRemove?: (file: File) => void;
+}
+
+export declare interface FileDropzoneProps {
+    /**
+     * Controlled list of files. Omit for uncontrolled — the dropzone
+     * holds its own internal list and emits adds/removes via callbacks.
+     */
+    value?: File[];
+    /** Controlled counterpart — fires with the full updated list. */
+    onValueChange?: (files: File[]) => void;
+    /**
+     * Fires with files that passed validation and were added to the set.
+     * Useful when you want to start an upload immediately rather than
+     * wait for an explicit "Submit" action.
+     */
+    onFilesAdded?: (files: File[]) => void;
+    /**
+     * Fires with files that were dropped/selected but rejected. Report
+     * these to the user — typically via a toast or inline error.
+     */
+    onReject?: (rejections: FileRejection[]) => void;
+    /**
+     * MIME types or extensions accepted by the file picker. Passed
+     * verbatim to the native `<input>` `accept` attribute. Use the
+     * native format: `"image/*,application/pdf,.jsonl"`.
+     */
+    accept?: string;
+    /** Max files in the total set. Defaults to `Infinity`. */
+    maxFiles?: number;
+    /** Max size per file in bytes. Defaults to `Infinity`. */
+    maxSize?: number;
+    /** Allow multiple selections. Default `true`. */
+    multiple?: boolean;
+    /** Disable interaction + dim the surface. */
+    disabled?: boolean;
+    /**
+     * Error state — destructive border + `aria-invalid`. Mirrors
+     * Input / Select / Textarea so form primitives share a surface.
+     */
+    error?: boolean | string;
+    /**
+     * Override the default empty-state UI. When omitted, a centered
+     * upload icon + "Drop files here or click to browse" label renders
+     * using the `accept` / `maxSize` props as the hint line.
+     */
+    children?: React_2.ReactNode;
+    className?: string;
+}
+
+/**
+ * FileDropzone — drag-and-drop file upload surface.
+ *
+ * Shadcn doesn't ship a first-class file-upload primitive in the core
+ * registry, so this is Atlas's canonical version — built in the same
+ * house style: `cn()`, `forwardRef`, design-token palette, composable
+ * via children, and zero external dependencies (no `react-dropzone`).
+ *
+ * Core behaviors:
+ *   - Drag-and-drop OR click-to-browse OR keyboard (Enter/Space)
+ *   - Paste support (Ctrl/Cmd+V while focused)
+ *   - Validation: `accept` (mime / extension), `maxFiles`, `maxSize`
+ *   - Rejection reporting via `onReject({ file, reason })`
+ *   - Controlled (`value` + `onValueChange`) or uncontrolled
+ *   - Matches Input/Select/Textarea on radius (8px), border color
+ *     (`border-input` dashed), and focus ring (1px). Surface is
+ *     `bg-muted` — a subtle tinted fill that differentiates the drop
+ *     target from the white page backdrop. Hover / drag states
+ *     darken via `bg-accent/40` and `bg-accent/60` respectively.
+ *
+ * Usage — simplest form (uncontrolled):
+ * ```tsx
+ * <FileDropzone accept="image/*" maxSize={5 * 1024 * 1024} onFilesAdded={upload} />
+ * ```
+ *
+ * Controlled with file list:
+ * ```tsx
+ * const [files, setFiles] = useState<File[]>([])
+ * <FileDropzone value={files} onValueChange={setFiles} multiple />
+ * <FileDropzoneList files={files} onRemove={(f) => setFiles(prev => prev.filter(x => x !== f))} />
+ * ```
+ */
+export declare interface FileRejection {
+    file: File;
+    /**
+     * Reason the file was rejected. Discrete codes so consumers can
+     * localize or branch on them rather than parsing strings.
+     */
+    reason: 'invalid-type' | 'too-large' | 'too-many' | 'empty';
+    message: string;
+}
+
+/** @deprecated Use `MultiSelectOption` from `./multi-select`. */
+export declare interface FilterOption<T extends string> {
+    value: T;
+    label: string;
+    /** Optional visual (colored badge, dot) shown beside the label. */
+    swatch?: ReactNode;
+}
+
+export declare function FilterPill({ label, options, selected, onChange }: FilterPillProps): JSX.Element | null;
+
+/**
+ * @deprecated Do not use in new code, and migrate existing usages off it.
+ * `FilterPill` is being retired from the design system: filtering must go
+ * through the canonical support — `ProDataTable`'s native filter funnel
+ * (`meta.filter` → `FilterMenu`), which owns state, ordering (search always
+ * before filter), and DS-composed controls. This standalone pill is removed
+ * from the design-system gallery; it is still exported from
+ * `@sequenceholdings/atlas-ui` (deprecated) purely so existing consumers keep
+ * compiling — kept only until the remaining app consumers (chat / crm /
+ * permissions / groups / jarvis / billing) are migrated to the funnel, after
+ * which the exports and this file go away (DES-126).
+ *
+ * FilterPill — a compact multi-select filter anchored to a table toolbar.
+ *
+ * Visual contract mirrors `SelectTrigger` so a toolbar of FilterPills +
+ * SearchInput + Select reads as one coherent row of controls, not a
+ * grab-bag of visual treatments:
+ *
+ *   - Height:        h-9 (36px)
+ *   - Radius:        rounded-sm (8px, `--radius-sm`)
+ *   - Border/bg:     `border bg-card` — `--input` border, raised surface,
+ *                    same palette as Select/Input. NOT `background`: that is
+ *                    the PAGE role (ds-neutral-50 under v2, not white), which
+ *                    rendered the pill as a grey chip next to the white
+ *                    outline controls beside it. `Button variant="outline"`
+ *                    carries the same note and the same `dark:bg-input/30`
+ *                    lift, since in dark the resting fill matches the darkest
+ *                    surface and vanishes.
+ *   - Padding:       px-3 py-1
+ *   - Text:          text-base md:text-sm (14px on desktop)
+ *   - Focus ring:    focus:ring-1 focus:ring-ring (keyboard-visible)
+ *
+ * Rationale for NOT using `rounded-full` + primary fill (the old shape):
+ *   1. Visual noise. When a toolbar mixes a SearchInput (8px radius),
+ *      two FilterPills (full radius), and a Select (8px radius), the
+ *      eye has to re-parse each control. A consistent radius reads as
+ *      one group.
+ *   2. Active state hierarchy. A solid primary-colored pill made the
+ *      active filter feel like a CTA. Filters are not CTAs — the
+ *      primary action on a dashboard is "run query" / "save", not
+ *      "I've narrowed my view". A subtle count chip communicates
+ *      activity without competing with real buttons.
+ *
+ * Active state now uses a tiny pill-shaped count badge next to the
+ * label. The trigger itself stays in the Select-aligned neutral look.
+ */
+declare interface FilterPillProps {
+    label: string;
+    options: string[];
+    selected: string[];
+    onChange: (values: string[]) => void;
+}
+
+/**
+ * @deprecated Do not use in new code, and migrate existing usages off it.
+ * `FilterSelect` is retired in favor of `MultiSelect` (searchable cmdk list,
+ * always-visible checkboxes, stacked trigger icons). It is still exported from
+ * `@sequenceholdings/atlas-ui` (deprecated) so remaining consumers keep
+ * compiling — remove only after the blast-radius scan is clean (FilterPill /
+ * DES-261 deprecate-before-delete pattern).
+ *
+ * A compact multi-select filter for a table/list toolbar: a trigger with a count
+ * chip when active, and a popover of swatch + label rows with a check on the
+ * selected ones. Reusable for any short enum filter (status, health, type, …).
+ *
+ * "Active" means the filter actually narrows the set — neither all nor none
+ * selected — so an all-selected filter reads as a neutral control, not an
+ * applied one.
+ */
+export declare function FilterSelect<T extends string>({ label, options, selected, onChange, }: FilterSelectProps<T>): JSX.Element;
+
+/** @deprecated Use `MultiSelect` props instead. */
+export declare interface FilterSelectProps<T extends string> {
+    label: string;
+    options: FilterOption<T>[];
+    selected: T[];
+    onChange: (next: T[]) => void;
+}
+
+/**
+ * Format a byte count to a human-readable string. Matches the
+ * conventions users expect in file dialogs: 1024-base, one decimal
+ * place once past KB.
+ */
+export declare function formatBytes(bytes: number): string;
+
+export declare function formatCompact(value: number): string;
+
+export declare function formatCurrency(value: number): string;
+
+export declare function formatCurrencyPrecise(value: number): string;
+
+export declare function formatDurationMs(ms: number): string;
+
+export declare function formatNumber(value: number): string;
+
+export declare function formatPercent(value: number): string;
+
+export declare function formatTimestamp(date: string | Date): string;
+
+/**
+ * A reusable create/edit dialog shell: title (+ optional description), a
+ * scrollable body for the fields, an inline error, and a Cancel / submit footer
+ * with a saving state. Owns all the dialog chrome so each form only supplies its
+ * fields and an `onSubmit`.
+ */
+export declare function FormDialog({ open, onOpenChange, title, description, submitLabel, submittingLabel, onSubmit, submitting, canSubmit, error, widthClassName, children, }: FormDialogProps): JSX.Element;
+
+export declare interface FormDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: ReactNode;
+    submitLabel: string;
+    submittingLabel?: string;
+    onSubmit: () => void;
+    submitting?: boolean;
+    /** Disable the submit button (e.g. required fields not yet filled). */
+    canSubmit?: boolean;
+    /** Inline error rendered above the footer. */
+    error?: string | null;
+    /** Tailwind max-width class for the dialog (default `max-w-2xl`). */
+    widthClassName?: string;
+    children: ReactNode;
+}
+
+/**
+ * Compound form-field wrapper — the label + control + error/description
+ * triple, wired up correctly.
+ *
+ * ```tsx
+ * <FormField label="Customer name" required error={errors.name}>
+ *   <Input value={name} onChange={e => setName(e.target.value)} />
+ * </FormField>
+ * ```
+ *
+ * Handles three things consumers otherwise have to do by hand:
+ *
+ *   1. `id` + `htmlFor` wiring — auto-generated via `useId()` when
+ *      omitted, so the label clicks focus the control.
+ *   2. `aria-describedby` — points the control at the description
+ *      and/or error message element(s) for assistive tech.
+ *   3. Error-state propagation — passes `error={!!error}` down to the
+ *      child control so its border/ring flip to destructive tokens
+ *      without the caller having to duplicate the flag.
+ *
+ * For manual composition (Label + Input as siblings), everything the
+ * FormField does is still reachable as individual primitives. Use FormField
+ * when you want the 90% case in one line.
+ */
+export declare function FormField({ label, required, error, description, descriptionPlacement, id: providedId, children, className, }: FormFieldProps): JSX.Element;
+
+export declare interface FormFieldProps {
+    /**
+     * Label text rendered above the control. Pass a string for the common
+     * case; pass a ReactNode for custom content (e.g. a Label with an
+     * adjacent HelpTooltip icon). When omitted, the field renders its
+     * control only — useful for nesting a raw control inside a layout
+     * without forcing a label.
+     */
+    label?: React_2.ReactNode;
+    /**
+     * When true, appends a red `*` marker to the label. No-op without `label`.
+     */
+    required?: boolean;
+    /**
+     * Error message. When non-empty, the control inside is styled with its
+     * error state and this message renders below in destructive color.
+     * Mutually exclusive with `description` (error wins when both are set).
+     */
+    error?: string;
+    /**
+     * Helper text rendered in muted color (field hint, input format, etc).
+     * Placement is controlled by {@link descriptionPlacement}. When placed
+     * `below` (default), an `error` takes the same slot and hides it.
+     */
+    description?: React_2.ReactNode;
+    /**
+     * Where the {@link description} sits relative to the control:
+     *   - `below` (default) — the classic helper-text slot beneath the control.
+     *   - `above` — a caption between the label and the control, for fields
+     *     where the description explains what to pick before you pick it
+     *     (e.g. a multi-select of capabilities). An `error` still renders below.
+     */
+    descriptionPlacement?: 'above' | 'below';
+    /**
+     * DOM id for the control. If omitted, `useId()` generates one so
+     * `<label htmlFor>` and `aria-describedby` wire up automatically.
+     */
+    id?: string;
+    /**
+     * The form control. `FormField` clones this child to inject `id`,
+     * `aria-describedby`, and — when `error` is set — the child's
+     * `error` prop. Must be a single element (Input / Textarea / Select
+     * trigger / etc).
+     */
+    children: React_2.ReactElement;
+    className?: string;
+}
+
+export declare function GenericAvatar({ size, className }: GenericAvatarProps): JSX.Element;
+
+export declare interface GenericAvatarProps {
+    /** Size in px. Defaults to 20. */
+    size?: number;
+    className?: string;
+}
+
+/**
+ * Maps a numeric value within [min, max] to a warm green→amber background.
+ * Returns `undefined` for zero / degenerate ranges so the caller can skip styling.
+ */
+export declare function heatColor(value: number, min: number, max: number): string | undefined;
+
+/**
+ * Sortable, paginated table with heat-colored numeric cells.
+ *
+ * Pair with `buildPeriodColumns` and `buildTotalColumn` for time-series
+ * data, or supply your own `ColumnDef` array for any tabular layout.
+ */
+export declare function HeatmapTable<T>({ data, columns, pageSize, defaultSort, onRowClick, entityLabel, density, className, }: HeatmapTableProps<T>): JSX.Element;
+
+export declare interface HeatmapTableProps<T> {
+    data: T[];
+    columns: ColumnDef<T>[];
+    pageSize?: number;
+    defaultSort?: SortingState;
+    onRowClick?: (row: T) => void;
+    /** Label used in pagination ("1–10 of 42 {entityLabel}") and empty state. */
+    entityLabel?: string;
+    /** Tightens cell padding for dense, many-column matrices. */
+    density?: 'default' | 'compact' | 'dense';
+    className?: string;
+}
+
+export declare const HoverCard: React_2.FC<HoverCardPrimitive.HoverCardProps>;
+
+export declare const HoverCardContent: React_2.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const HoverCardTrigger: React_2.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React_2.RefAttributes<HTMLAnchorElement>>;
+
+/**
+ * Click-to-edit date cell. Shows a custom (or default) display until clicked,
+ * then a native date input that commits on change/blur. The closed display is a
+ * render prop so callers can style it (e.g. a due-date heat pill).
+ */
+export declare function InlineDateCell({ value, onCommit, renderDisplay, placeholder, title, className, }: InlineDateCellProps): JSX.Element;
+
+export declare interface InlineDateCellProps {
+    /** ISO date string (YYYY-MM-DD) or null. */
+    value: string | null;
+    onCommit: (value: string | null) => void | Promise<void>;
+    /** Closed-state display for the value; defaults to the raw date or a dash. */
+    renderDisplay?: (value: string | null) => ReactNode;
+    placeholder?: string;
+    title?: string;
+    className?: string;
+}
+
+/**
+ * Click-to-edit text cell. Reads as plain text until clicked, then becomes a
+ * borderless auto-growing textarea that commits on blur / Enter (⌘/Ctrl+Enter
+ * for multiline) and cancels on Escape. Empty commits to null; `required`
+ * fields revert instead. Domain-agnostic — pairs with any table cell.
+ */
+export declare function InlineTextCell({ value, onCommit, placeholder, multiline, required, className, displayClassName, }: InlineTextCellProps): JSX.Element;
+
+export declare interface InlineTextCellProps {
+    value: string | null;
+    onCommit: (value: string | null) => void | Promise<void>;
+    placeholder?: string;
+    multiline?: boolean;
+    required?: boolean;
+    /** Extra classes for the editing textarea. */
+    className?: string;
+    /** Extra classes for the read-only display button. */
+    displayClassName?: string;
+}
+
+export declare const Input: React_2.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React_2.RefAttributes<HTMLInputElement>>;
+
+declare interface InputOwnProps {
+    /**
+     * When truthy, the input renders in its error state — destructive
+     * border, destructive focus ring, and `aria-invalid="true"` for
+     * assistive tech.
+     *
+     * Accepts `boolean` (to toggle styling) or `string` (for convenience
+     * — any non-empty string is truthy). The error *message* itself is
+     * rendered by the caller (or automatically by `<Field error="...">`);
+     * this prop only controls the input's own visual state.
+     */
+    error?: boolean | string;
+}
+
+export declare type InputProps = React_2.ComponentProps<"input"> & InputOwnProps;
+
+/**
+ * Whether a declarative field is inline-editable: it carries an editor
+ * (`options` + `onChange`), hasn't opted out (`readOnly`), and isn't using
+ * the bespoke static `render` escape hatch.
+ */
+export declare function isFieldEditable(field: TaskFieldDef): boolean;
+
+export declare function KpiTile({ label, labelAdornment, onLabelClick, value, delta, deltaTone, footer, tone, valueAdornment, pinValue, className, onClick, }: KpiTileProps): JSX.Element;
+
+/**
+ * KpiTileGrid — opinionated 1-D grid of KPI tiles. Responsive: wraps at small
+ * widths, up to `columns` at wide widths.
+ */
+export declare function KpiTileGrid({ columns, className, children, }: {
+    columns?: 2 | 3 | 4 | 5;
+    className?: string;
+    children: React_2.ReactNode;
+}): JSX.Element;
+
+declare interface KpiTileProps {
+    label: string;
+    /** Inline adornment rendered immediately after the label (e.g. info icon). */
+    labelAdornment?: React_2.ReactNode;
+    /**
+     * When set, the label text becomes a button that fires this handler.
+     * Adornments stay separate (their own buttons handle their own clicks),
+     * so consumers can keep info / remove / log affordances next to a
+     * clickable title without overlapping hit-targets.
+     */
+    onLabelClick?: () => void;
+    value: React_2.ReactNode;
+    /** Delta chip rendered next to the value (e.g. "+12%"). */
+    delta?: React_2.ReactNode;
+    /** Green for positive, red for negative; neutral when omitted. */
+    deltaTone?: 'positive' | 'negative' | 'neutral';
+    /** Optional small line of text below the value (captions, context). */
+    footer?: React_2.ReactNode;
+    /** When 'warn', the tile picks up an amber tint to flag attention. */
+    tone?: KpiTone;
+    /** Inline adornment rendered next to the value (e.g. live dot). */
+    valueAdornment?: React_2.ReactNode;
+    /**
+     * Pin the value+footer block to the bottom of the tile instead of
+     * letting the value float right below the label. Use for tiles where
+     * the value should stay anchored to chart/progress content
+     * regardless of how tall the label gets (e.g. a label that wraps to
+     * two lines). Also drops the default `truncate` on the footer wrapper
+     * since pinned-value consumers typically pass a multi-element footer
+     * (progress bar + chip) where truncation would clip the layout.
+     */
+    pinValue?: boolean;
+    className?: string;
+    onClick?: () => void;
+}
+
+/**
+ * KpiTile — compact metric card for the top of dashboards.
+ *
+ * Differs from `MetricCard` in two deliberate ways:
+ *   - supports a colored "warn" state (tinted background/border) for KPIs that
+ *     themselves carry an attention signal (e.g. "Needs attention: 1")
+ *   - exposes `delta`, `deltaTone`, and `footer` slots so the monitoring-style
+ *     copy ("+0.4pp vs prev 24h", "5 agents live") renders consistently
+ *
+ * When you only need a static label + value + subtitle, prefer MetricCard.
+ */
+declare type KpiTone = 'neutral' | 'warn' | 'info';
+
+export declare const Label: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ClassProp | undefined) => string> & LabelOwnProps & React_2.RefAttributes<HTMLLabelElement>>;
+
+export declare function LabeledSelect({ label, icon, value, options, onChange, ariaLabel, prefixHiddenValues, className, }: LabeledSelectProps): JSX.Element;
+
+export declare interface LabeledSelectOption {
+    value: string;
+    label: string;
+}
+
+export declare interface LabeledSelectProps {
+    /** Muted prefix shown before the value, e.g. `"Group by"` / `"Sorted by"`. */
+    label: string;
+    /** Leading glyph (kept small + muted by the pill). */
+    icon?: React_2.ReactNode;
+    value: string;
+    options: LabeledSelectOption[];
+    onChange: (value: string) => void;
+    /** Accessible name for the trigger. Defaults to `label`. */
+    ariaLabel?: string;
+    /**
+     * Values for which the muted prefix is hidden — the pill shows just the
+     * value. Use for "off"/"none" states where the prefix reads awkwardly
+     * (e.g. `'none'` → "No grouping", not "Group by No grouping").
+     */
+    prefixHiddenValues?: readonly string[];
+    className?: string;
+}
+
+declare interface LabelOwnProps {
+    /**
+     * When true, appends a red `*` marker after the label text. Prefer this
+     * over rendering `<RequiredMarker />` manually — keeps the marker
+     * positioning consistent and makes required-ness a declarative prop
+     * at the call site. Also consumed by `<FormField required>` which
+     * forwards it through to the label automatically.
+     */
+    required?: boolean;
+}
+
+declare type LegendPayloadItem = {
+    value?: string | number;
+    dataKey?: string | number;
+    color?: string;
+};
+
+export declare function LineSparklineCell({ values, width, height, scaleMax, color, label, className, }: LineSparklineCellProps): JSX.Element;
+
+declare interface LineSparklineCellProps {
+    values: number[];
+    width?: number;
+    height?: number;
+    /** Y-axis max — defaults to 100 for percent metrics. */
+    scaleMax?: number;
+    color?: string;
+    label?: React_2.ReactNode;
+    className?: string;
+}
+
+/**
+ * Recharts area chart for a metric's record series — the shared primitive behind
+ * the metric sparkline (cards) and the metric detail view. Mirrors the Jarvis
+ * metric-card chart (gradient area, monotone line) so metric viz reads the same
+ * everywhere. Lives in atlas-ui so standalone artifacts can reuse it without
+ * pulling chart.js.
+ */
+export declare function MetricAreaChart({ points, color, height, variant, valueFormatter, dateFormatter, className, }: MetricAreaChartProps): JSX.Element;
+
+export declare interface MetricAreaChartPoint {
+    t: string;
+    v: number;
+}
+
+export declare interface MetricAreaChartProps {
+    points: MetricAreaChartPoint[];
+    /** Stroke / fill color for the area. Defaults to the semantic "positive series" token. */
+    color?: string;
+    height?: number;
+    /** `spark` = compact, axis-less (cards); `full` = axes + grid + tooltip. */
+    variant?: 'spark' | 'full';
+    valueFormatter?: (value: number) => string;
+    dateFormatter?: (iso: string) => string;
+    className?: string;
+}
+
+export declare function MetricCard({ label, value, subtitle, compact, className, onClick, children }: MetricCardProps): JSX.Element;
+
+declare interface MetricCardProps {
+    label: string;
+    value: ReactNode;
+    subtitle?: ReactNode;
+    compact?: boolean;
+    className?: string;
+    onClick?: () => void;
+    children?: ReactNode;
+}
+
+export declare function MetricGrid({ columns, children, className }: MetricGridProps): JSX.Element;
+
+declare interface MetricGridProps {
+    columns?: 2 | 3 | 4 | 5;
+    children: ReactNode;
+    className?: string;
+}
+
+export declare function MultiSelect({ label, countLabel, options, selected, onChange, searchPlaceholder, emptyMessage, maxStackedIcons, hideWhenEmpty, className, }: MultiSelectProps): JSX.Element | null;
+
+/**
+ * Fields shared by `MultiSelect` (trigger + popover) and the standalone
+ * `MultiSelectList` body: the options and how selection is read/written.
+ * Trigger-only and list-only props live on the respective interfaces.
+ */
+declare interface MultiSelectCoreProps {
+    options: MultiSelectOption[];
+    selected: string[];
+    onChange: (values: string[]) => void;
+    /** Placeholder for the inline search input. */
+    searchPlaceholder?: string;
+    /** Empty-state message when the search matches nothing. */
+    emptyMessage?: string;
+}
+
+/**
+ * MultiSelectList — the searchable, checkbox-list body of `MultiSelect`,
+ * extracted so it can be embedded outside the default Popover trigger.
+ * `MultiSelect` renders it inside its own PopoverContent; other callers
+ * (e.g. a Linear-style filter built on a Radix DropdownMenu submenu) can
+ * drop it into any floating container and get the same rows, search,
+ * pinned grouping, and icon-column behavior.
+ */
+export declare function MultiSelectList({ options, selected, onChange, searchPlaceholder, emptyMessage, query, onQueryChange, className, searchable, }: MultiSelectListProps): JSX.Element;
+
+declare interface MultiSelectListProps extends MultiSelectCoreProps {
+    /** Controlled search query. Omit to let the list manage its own. */
+    query?: string;
+    onQueryChange?: (query: string) => void;
+    className?: string;
+    /** Show the search input. Default true (see `SelectListShellProps`). */
+    searchable?: boolean;
+}
+
+/**
+ * MultiSelect — a filter-bar facet with a searchable multi-select
+ * dropdown. Modeled after Linear's filter pills: stacked icons in the
+ * trigger when active, inline X to clear, searchable cmdk list with
+ * optional pinned (virtual) rows like "No assignee".
+ *
+ * Composition:
+ *   - Popover (Radix) for the floating container.
+ *   - Command (cmdk) for the searchable list and keyboard nav.
+ *   - Checkbox (Radix) for per-row selection state.
+ *
+ * Visual contract for the trigger mirrors `SelectTrigger` (h-9, rounded-sm,
+ * border + bg-field) so a toolbar of MultiSelect + Input + Select reads
+ * as one coherent control row. Active state stacks up to `maxStackedIcons`
+ * selected-row icons (with a generic silhouette for icon-less rows) and
+ * shows "{count} {countLabel}" alongside.
+ *
+ * Composition safety: the active trigger keeps `border-input` (NOT
+ * `border-foreground`). `--foreground` is near-black, so swapping to
+ * it on selection produced a heavy black outline that competed with
+ * real CTAs. Active state is conveyed by the stacked icons + bold
+ * count + X, not by the chrome. See DESIGN.md "Composition safety".
+ */
+export declare interface MultiSelectOption {
+    /** Stable identifier — what shows up in `selected` and `onChange`. */
+    value: string;
+    /** Display text for the row and the cmdk search index. */
+    label: string;
+    /**
+     * Optional secondary line beneath the label (e.g. an email under a name).
+     * Disambiguates rows that share a label — two people with the same name.
+     * Truncates like the label. Pure presentational — not searched (add the
+     * same text to `keywords` to also match on it).
+     */
+    sublabel?: ReactNode;
+    /**
+     * Optional leading visual (e.g. avatar). Renders before the label in
+     * the row, and stacks in the trigger when this option is selected.
+     * Size yourself to ~20px square so the row vertical rhythm holds.
+     */
+    icon?: ReactNode;
+    /**
+     * Optional right-aligned secondary text (e.g. "8 issues"). Pure
+     * presentational — not searched.
+     */
+    meta?: ReactNode;
+    /**
+     * Pin this option above a separator at the top of the list (e.g.
+     * "No assignee", "Current user"). Pinned options render in their
+     * caller-provided order regardless of search ranking.
+     */
+    pinned?: boolean;
+    /**
+     * Extra strings to include in the search index alongside `label`.
+     * Useful when the visible label is a name but you also want to
+     * match an email or alias.
+     */
+    keywords?: string[];
+}
+
+declare interface MultiSelectProps extends MultiSelectCoreProps {
+    /** Inactive trigger label (e.g. "People", "Assignee"). */
+    label: string;
+    /**
+     * Plural noun shown after the count in the active trigger
+     * ("3 {countLabel}"). Defaults to `label.toLowerCase()`.
+     */
+    countLabel?: string;
+    /**
+     * Max number of selected-row icons to stack in the trigger. Beyond
+     * this, additional selected rows roll up into the count. Defaults
+     * to 3 (matches Linear's behavior).
+     */
+    maxStackedIcons?: number;
+    /**
+     * Hide the trigger entirely when `options` is empty. Defaults to
+     * true — empty filter chips clutter a toolbar. Pass `false` when
+     * the chip should be visible (e.g. as an affordance for a list
+     * that hasn't loaded yet).
+     */
+    hideWhenEmpty?: boolean;
+    className?: string;
+}
+
+/**
+ * Snapshot of every matching cache entry, captured in `onMutate` for rollback.
+ */
+export declare interface OptimisticListContext<TCache> {
+    previous: [QueryKey, TCache | undefined][];
+    optimisticMutationId?: number;
+    queryKeyHash?: string;
+}
+
+/**
+ * Snapshot captured in `onMutate`, used to roll the cache back on error.
+ */
+export declare interface OptimisticResourceContext<TData> {
+    previous: TData | undefined;
+    optimisticMutationId?: number;
+    queryKeyHash?: string;
+}
+
+/**
+ * A small, reusable inline picker: the current value renders as a clickable
+ * badge/dot that opens a popover of the actual options (each shown with its own
+ * swatch + a check on the active one). A nicer, on-brand replacement for a
+ * native <select> for short, visual enum fields like status and health.
+ */
+export declare function OptionPicker<T extends string>({ value, options, onChange, children, ariaLabel, align, triggerClassName, contentClassName, }: OptionPickerProps<T>): JSX.Element;
+
+export declare interface OptionPickerProps<T extends string> {
+    value: T;
+    options: PickerOption<T>[];
+    onChange: (value: T) => void;
+    /** Closed-state trigger content (the badge / dot shown in the row). */
+    children: ReactNode;
+    ariaLabel?: string;
+    align?: 'start' | 'center' | 'end';
+    /** Extra classes for the trigger button (e.g. padding around a small dot). */
+    triggerClassName?: string;
+    contentClassName?: string;
+}
+
+export declare function PageSkeleton({ variant, className }: PageSkeletonProps): JSX.Element;
+
+export declare interface PageSkeletonProps {
+    variant?: PageSkeletonVariant;
+    className?: string;
+}
+
+export declare type PageSkeletonVariant = 'default' | 'list' | 'detail' | 'dashboard';
+
+export declare function pctChange(current: number, previous: number): number | null;
+
+export declare function PercentCell({ value, dangerBelow, className, }: {
+    value: number | null | undefined;
+    dangerBelow?: number;
+    className?: string;
+}): JSX.Element;
+
+export declare interface PickerOption<T extends string> {
+    value: T;
+    /** Optional text label; omit when the swatch already reads as the option. */
+    label?: string;
+    /** The option's visual — a colored badge, dot, etc. */
+    swatch: ReactNode;
+}
+
+export declare const Popover: React_2.FC<PopoverPrimitive.PopoverProps>;
+
+export declare const PopoverAnchor: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const PopoverContent: React_2.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const PopoverTrigger: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const PortalContainerContext: React_2.Context<PortalContainerContextValue>;
+
+declare interface PortalContainerContextValue {
+    container: HTMLElement | null;
+    appClassName?: string;
+}
+
+export declare function PortalContainerProvider({ children, appClassName, }: {
+    children: React_2.ReactNode;
+    appClassName?: string;
+}): JSX.Element;
+
+export declare type ProColumnDef<T> = ColumnDef<T, unknown> & {
+    meta?: ProColumnMeta;
+};
+
+/**
+ * ProDataTable — opinionated extension of the shadcn table for dashboard-style
+ * lists. Layered on top of `DataTable` so apps can opt into richer chrome:
+ *   - toolbar slot (search + filters + extras) above the header row
+ *   - uppercase, compact header cells with sort arrows (stateful)
+ *   - sticky-left columns for "name" identity (horizontal-scroll safe)
+ *   - selected/hover row styling + right-aligned numeric cells
+ *   - composable cell primitives exported from this module
+ *     (AvatarTextCell, SparklineCell, StatusDotBadge, ScoreBarCell, etc.)
+ *
+ * Consumers describe columns with TanStack's `ColumnDef<T>`. The `meta` field
+ * on each column is extended with optional presentational hints that live
+ * with the column definition (alignment, sticky, width, header tooltip).
+ */
+/**
+ * Column meta extension. Narrow, opt-in; backwards compatible with ColumnDef.
+ *
+ * Sizing model (rebuilt):
+ *   - `minWidth`   — hard lower bound. The cell never renders narrower than
+ *                    this, even when the table is squeezed. This is what
+ *                    triggers horizontal scroll when the sum of minimums
+ *                    exceeds the container. Defaults to `width` when only
+ *                    `width` is supplied, else `DEFAULT_MIN_WIDTH`.
+ *   - `width`      — preferred/fixed width in px. Use for compact utility
+ *                    columns (status pills, action menus, numeric cells).
+ *                    A column with `width` but no `grow` stays locked to
+ *                    `width` when the container is wide.
+ *   - `grow`       — when true, the column claims remaining horizontal space.
+ *                    Use for identity columns (name + subtitle) so they
+ *                    flex with the viewport. Multiple `grow` columns share
+ *                    remaining space proportionally.
+ *
+ * The table itself uses `table-layout: auto` + a computed `min-width` that
+ * equals the sum of per-column `minWidth`s plus container padding — so when
+ * the viewport shrinks past that threshold, horizontal scroll kicks in and
+ * every column stays at its own minimum instead of collapsing below it.
+ */
+/**
+ * Native per-column filter config. Attach to a column's `meta.filter` to opt
+ * that column into the toolbar filter menu (a single funnel button that lists
+ * every filterable column as a nested facet — the standard Atlas `FilterMenu`).
+ *
+ * The table owns the filtering: it wires the facet to TanStack's column-filter
+ * state and drops rows whose cell value doesn't match. This is a client-side
+ * feature — it's ignored under `manualPagination` (the parent already paged the
+ * rows server-side, so it owns filtering too).
+ *
+ *   - `type: 'multi'`  — checklist; a row matches if its value is in the set.
+ *   - `type: 'single'` — pick one value; a row matches if it equals the pick.
+ *
+ * `options` is optional: when omitted the table derives the distinct values of
+ * the column from `data` (value used verbatim as the label). Supply `options`
+ * to control the option set, ordering, or human labels (e.g. map a status code
+ * to a readable name). Matching always compares against the column's own cell
+ * value coerced to a string, so option `value`s must equal that string form.
+ */
+export declare type ProColumnFilter = {
+    type: 'multi';
+    /** Facet label in the menu. Defaults to the column's string header. */
+    label?: string;
+    /** Explicit options. Omit to auto-derive distinct values from `data`. */
+    options?: MultiSelectOption[];
+    /** Search-input placeholder inside the facet submenu. Defaults to the label. */
+    searchPlaceholder?: string;
+} | {
+    type: 'single';
+    label?: string;
+    options?: MultiSelectOption[];
+    searchPlaceholder?: string;
+    /**
+     * Value that counts as "no filter" (e.g. an `'all'` default). When the
+     * pick equals this, the facet is inactive and "Clear all" resets to it.
+     */
+    defaultValue?: string;
+};
+
+/**
+ * Discriminated union on `sticky`. The variants enforce at compile time that
+ * `{ sticky: true, grow: true }` can't be declared — callers get a TS error
+ * instead of silent layout corruption.
+ */
+export declare type ProColumnMeta = ProColumnMetaSticky | ProColumnMetaNonSticky;
+
+/**
+ * Fields shared by every column regardless of sticky / grow.
+ *
+ * `sticky` and `grow` are intentionally omitted here — they're added by the
+ * two `ProColumnMeta` variants below to form a discriminated union that makes
+ * `{ sticky: true, grow: true }` unrepresentable.
+ */
+declare interface ProColumnMetaBase {
+    align?: 'left' | 'right' | 'center';
+    /** Preferred pixel width. Locks the column unless `grow` is also set. */
+    width?: number;
+    /** Lower bound — column never renders narrower than this. */
+    minWidth?: number;
+    /** Header cell monospace / text hint. Body follows column cell content. */
+    headerMono?: boolean;
+    /** Extra className applied to the <th>. */
+    headerClassName?: string;
+    /** Extra className applied to every <td>. */
+    cellClassName?: string;
+    /** Hide default sort indicator even when column is sortable. */
+    hideSortIndicator?: boolean;
+    /**
+     * Opt this specific column out of user resizing when the table is rendered
+     * with `resizableColumns`. Defaults to resizable. Set `false` for columns
+     * whose width is intentionally fixed (action / overflow-menu columns, tight
+     * numeric cells) so they don't sprout a drag handle.
+     */
+    enableResizing?: boolean;
+    /**
+     * Mark a column whose cells carry their own control (checkbox, status
+     * toggle, delete button). Clicks anywhere in the cell — including the
+     * padding around the control — stop at the cell instead of bubbling to
+     * the row's `onRowClick`, so a near-miss on the control can't navigate
+     * away. The control itself no longer needs its own `stopPropagation`.
+     */
+    interactive?: boolean;
+    /**
+     * Opt this column into the toolbar filter menu. See {@link ProColumnFilter}.
+     * Client-side only — ignored under `manualPagination`.
+     */
+    filter?: ProColumnFilter;
+}
+
+/**
+ * Column meta for a non-sticky column. `grow: true` opts the column into
+ * absorbing remaining horizontal space (identity / title columns typically
+ * want this; utility columns do not).
+ */
+declare interface ProColumnMetaNonSticky extends ProColumnMetaBase {
+    sticky?: false;
+    /** When true, column flexes to fill remaining horizontal space. */
+    grow?: boolean;
+}
+
+/**
+ * Column meta for a sticky (pinned) column.
+ *
+ * Sticky columns pin to EITHER the left or right edge of the scroll
+ * region. Both sides support a contiguous block — for left, the block
+ * starts at the leftmost column; for right, at the rightmost. The first
+ * non-sticky column ends the chain on each side (dev-mode warning if a
+ * sticky declaration follows the break).
+ *
+ * API:
+ *   - `sticky: true`   → equivalent to `sticky: 'left'` (backward compat)
+ *   - `sticky: 'left'` → pin to the left edge. Common for identity
+ *                        columns (name, row ID).
+ *   - `sticky: 'right'`→ pin to the right edge. Common for action
+ *                        columns (overflow menu, status).
+ *
+ * The innermost pinned cell on each side (rightmost of the left block,
+ * leftmost of the right block) gets an edge shadow when the scrollable
+ * content has room to move away from that side — i.e., left-edge shadow
+ * appears after the user scrolls right past the start, right-edge shadow
+ * appears until the user scrolls to the end. The shadow indicates that
+ * content is currently being occluded BY the pinned cell.
+ *
+ * `grow` is disallowed on sticky columns — a grown sticky column renders at
+ * `width: 100%` which both breaks the cumulative offset math used to pin
+ * subsequent sticky columns and makes the pinned region balloon to fill
+ * the viewport. Set an explicit `width` (and optional `minWidth`) instead.
+ */
+declare interface ProColumnMetaSticky extends ProColumnMetaBase {
+    sticky: true | 'left' | 'right';
+    /**
+     * @deprecated `grow` is not allowed on sticky columns. Use `width` +
+     * `minWidth` to give the sticky column a deterministic size.
+     */
+    grow?: never;
+}
+
+export declare function ProDataTable<T>({ columns, data, selectable, getRowId, selectedRowIds, onSelectionChange, enableRowSelection, rowActions, getRowLabel, searchable, filters, toolbar, actions, footer, pageSize, disablePagination, resizableColumns, columnSizingStorageKey, defaultSort, manualPagination, rowCount, pageIndex, onPageChange, manualSorting, sorting: controlledSorting, onSortingChange, manualFiltering, columnFilters: controlledColumnFilters, onColumnFiltersChange, loading, emptyMessage, onRowClick, rowHref, rowClassName, minWidth, height, bordered, variant, ariaLabel, className, }: ProDataTableProps<T>): JSX.Element;
+
+/**
+ * Native segmented filter for the toolbar (e.g. All / Groups / People). The
+ * table renders the pills; the caller owns the active value and the actual
+ * filtering of `data` (filters are frequently heterogeneous, so the predicate
+ * stays with the caller rather than being baked in).
+ */
+declare interface ProDataTableFilters {
+    value: string;
+    onChange: (value: string) => void;
+    options: ReadonlyArray<{
+        id: string;
+        label: string;
+    }>;
+    ariaLabel?: string;
+}
+
+export declare function ProDataTablePagination<T>({ table, className, totalLabel, total: totalOverride }: ProDataTablePaginationProps<T>): JSX.Element;
+
+declare interface ProDataTablePaginationProps<T> {
+    table: Table_2<T>;
+    className?: string;
+    totalLabel?: (args: {
+        from: number;
+        to: number;
+        total: number;
+    }) => React_2.ReactNode;
+    /**
+     * True total across all pages. Required for manual (server) pagination, where
+     * the client row model only holds the current page — omit for client-side
+     * pagination, which derives the total from the filtered row model.
+     */
+    total?: number;
+}
+
+declare interface ProDataTableProps<T> {
+    columns: ProColumnDef<T>[];
+    data: T[];
+    /**
+     * Render a leading, left-pinned selection checkbox column (with a select-all
+     * header), backed by TanStack's row-selection model. The table owns the
+     * column and the state — pass `getRowId` for stable keys and read the result
+     * via `onSelectionChange`, or drive it with `selectedRowIds`. Prefer this
+     * over hand-rolling a checkbox column + selection `Set`.
+     */
+    selectable?: boolean;
+    /**
+     * Stable id per row. Strongly recommended with `selectable` — without it
+     * selection is keyed by row index and won't survive sort/filter/paging.
+     */
+    getRowId?: (row: T) => string;
+    /** Controlled selection (row ids). Omit for uncontrolled; read via `onSelectionChange`. */
+    selectedRowIds?: string[];
+    /** Called with the selected row ids whenever selection changes. */
+    onSelectionChange?: (ids: string[]) => void;
+    /** Gate which rows can be selected. Defaults to all rows selectable. */
+    enableRowSelection?: (row: T) => boolean;
+    /**
+     * Render a trailing, right-pinned overflow (⋯) menu, resolved per row. Return
+     * the actions for that row — an empty array (or all `hidden`) renders no
+     * button. Destructive actions automatically drop below a divider. Prefer this
+     * over hand-rolling an end-of-row action button + `DropdownMenu`.
+     */
+    rowActions?: (row: T) => RowAction[];
+    /**
+     * Human-readable per-row label for accessibility. When set, the injected
+     * selection checkbox and row-actions (⋯) trigger get row-specific aria-labels
+     * ("Select <label>" / "Actions for <label>") instead of generic repeated ones,
+     * so screen-reader users can tell which record they're acting on. Recommended
+     * whenever `selectable` or `rowActions` is used.
+     */
+    getRowLabel?: (row: T) => string;
+    /**
+     * Enable a client-side search input in the table header. Filters rows by
+     * concatenating every cell's accessor value (default) or via a custom
+     * accessor. Pass `true` for defaults, or an object to override.
+     */
+    searchable?: boolean | ProDataTableSearchable<T>;
+    /** Native segmented filter pills rendered in the toolbar. */
+    filters?: ProDataTableFilters;
+    /** Custom filter controls rendered next to the search input. */
+    toolbar?: React_2.ReactNode;
+    /**
+     * Action buttons pinned to the right edge of the toolbar (e.g. "New", an
+     * export button, an overflow menu). Kept in a dedicated right-aligned slot —
+     * separate from `toolbar` (left-aligned custom controls) — so primary
+     * actions read as distinct from the search/filter chrome. Rendering any
+     * toolbar content (search, filters, `toolbar`, or `actions`) shows the bar.
+     */
+    actions?: React_2.ReactNode;
+    /** Footer rendered below the table (e.g. custom summary row). */
+    footer?: React_2.ReactNode;
+    pageSize?: number;
+    /** Disable pagination entirely (small, known datasets). */
+    disablePagination?: boolean;
+    /**
+     * Let the user drag column borders to resize them. A grab handle appears on
+     * the right edge of every header cell (except columns with
+     * `meta.enableResizing: false`), drag to resize live, double-click a handle
+     * to reset that column to its default width. Only applies to the `table`
+     * variant (the `list` variant has no header to grab).
+     *
+     * Under resize mode, non-grow columns render at deterministic px widths.
+     * A `grow` column keeps its flex behavior (absorbing surplus container
+     * width) until the user drags it — at which point it becomes a
+     * deterministic px width like the rest; double-click reset restores the
+     * flex behavior. Keeping one grow column is what stops `table-layout:
+     * fixed` from distributing surplus across every column (which would
+     * desync sticky-offset math and inflate tight utility columns).
+     */
+    resizableColumns?: boolean;
+    /**
+     * When set alongside `resizableColumns`, per-column widths persist to
+     * `localStorage` under this key so a user's sizing survives reloads and
+     * re-mounts. Omit for session-only (in-memory) resizing. Failures to read
+     * or write storage are swallowed — resizing still works, it just won't
+     * persist.
+     */
+    columnSizingStorageKey?: string;
+    defaultSort?: SortingState;
+    /**
+     * Server-side (manual) pagination. When set, the table renders `data` as-is
+     * (already one server page) instead of slicing client-side, and reports
+     * position/total from `rowCount` + the controlled `pageIndex`. The pager's
+     * prev/next call `onPageChange` with the new zero-based page index; the parent
+     * refetches. Omit for the default client-side pagination — existing callers
+     * are unaffected.
+     */
+    manualPagination?: boolean;
+    /** Total row count across all server pages (manual pagination only). */
+    rowCount?: number;
+    /** Controlled zero-based page index (manual pagination only). */
+    pageIndex?: number;
+    /** Called with the new zero-based page index when the pager advances (manual pagination only). */
+    onPageChange?: (pageIndex: number) => void;
+    /**
+     * Server-side (manual) sorting. When set, header clicks call `onSortingChange`
+     * instead of reordering client rows — the parent maps the sort to its query
+     * and refetches. Pair with `sorting` (controlled state). Columns that have no
+     * server-sortable backing should set `enableSorting: false`.
+     */
+    manualSorting?: boolean;
+    /** Controlled sort state (manual sorting only). */
+    sorting?: SortingState;
+    /** Called with the next sort state on a header click (manual sorting only). */
+    onSortingChange?: (sorting: SortingState) => void;
+    /**
+     * Server-side (manual) column filtering. When set, the toolbar filter funnel
+     * renders even under `manualPagination`, but the table does NOT drop rows
+     * itself — it reflects the controlled `columnFilters` in the facets/pills and
+     * emits `onColumnFiltersChange` so the parent maps them to its query and
+     * refetches. Filterable columns MUST supply explicit `meta.filter.options`
+     * (distinct values can't be auto-derived from a single server page). Pair
+     * with `columnFilters`; the parent should reset `pageIndex` to 0 on change.
+     */
+    manualFiltering?: boolean;
+    /** Controlled column-filter state (manual filtering only). */
+    columnFilters?: ColumnFiltersState;
+    /** Called with the next column-filter state when a facet changes (manual filtering only). */
+    onColumnFiltersChange?: (filters: ColumnFiltersState) => void;
+    /**
+     * Dim the table body and show a centered spinner — for server-driven tables
+     * during a refetch (search/filter/sort/page change), so the grid doesn't
+     * flash empty or stale between requests.
+     */
+    loading?: boolean;
+    emptyMessage?: React_2.ReactNode;
+    onRowClick?: (row: T) => void;
+    /**
+     * Per-row destination URL. When provided alongside `onRowClick`, plain
+     * clicks still call `onRowClick` (SPA navigate), but Cmd/Ctrl-click,
+     * middle-click, and Shift-click open the URL in a new tab/window — same
+     * semantics as a real `<a>` element. Without this prop, modifier-clicks
+     * fall through to the plain handler and the user can't multi-open rows.
+     */
+    rowHref?: (row: T) => string | undefined;
+    rowClassName?: (row: Row<T>) => string | undefined;
+    /**
+     * Override the computed table min-width. By default, the component adds up
+     * each column's `minWidth` + horizontal padding to derive the threshold
+     * where horizontal scroll should kick in. Set this only if you need to
+     * force a larger minimum (e.g. to reserve room for a floating column).
+     */
+    minWidth?: number;
+    /**
+     * Explicit height for the table card. Overrides the default fill-parent
+     * behavior. Accepts any CSS length (`'600px'`, `'70vh'`,
+     * `'calc(100vh - 12rem)'`) or a pixel `number`.
+     *
+     * By default the card grows to fill its parent's available height via
+     * `flex-1` (for flex-column parents like DashboardShell body) and
+     * `h-full` (for fixed-height parents). The toolbar stays pinned at
+     * the top of the card, the body scrolls internally, and the header
+     * sticks to the top of the scroll region.
+     */
+    height?: string | number;
+    /** Wrap the whole thing in a rounded card. Defaults to true. */
+    bordered?: boolean;
+    /**
+     * `table` (default) renders column headers (sortable). `list` hides the
+     * header row for a clean borderless list — rows still carry the `border`
+     * inset dividers. Use for identity lists (people / groups) where column
+     * labels are noise. Sorting via header click isn't available in `list`;
+     * pass `defaultSort` for a fixed order.
+     */
+    variant?: 'table' | 'list';
+    /** Shown when the table is selected in a multi-table shell (optional). */
+    ariaLabel?: string;
+    className?: string;
+}
+
+/**
+ * Built-in search config for ProDataTable. The table owns the input and
+ * filters rows client-side via TanStack's globalFilter. Pass `true` for a
+ * default search bar, or an object to customize placeholder / matcher.
+ */
+declare interface ProDataTableSearchable<T> {
+    placeholder?: string;
+    /**
+     * Optional extractor used when the default includes-string matcher isn't
+     * enough (e.g. fuzzy search, concatenating several fields). Return the
+     * searchable text representation for a row. Client-side search only.
+     */
+    accessor?: (row: T) => string;
+    /** Width of the input in px. Defaults to 240. */
+    width?: number;
+    /**
+     * Controlled (server-side) search. When `onChange` is provided the table
+     * stops filtering client-side and hands the debounced query to the parent,
+     * which refetches — pair with `manualPagination`. Omit both for the default
+     * client-side filter over the loaded `data`.
+     *
+     * Once `value` is provided it is the source of truth for the input:
+     * keystrokes show instantly, but as soon as the debounce emits, the field
+     * renders `value` again. So rejecting or rewriting the query in `onChange` is
+     * reflected in the box rather than leaving a stale private copy behind, and a
+     * `value` the parent changes on its own cancels any unsent keystroke.
+     *
+     * Set your state to the emitted value synchronously inside `onChange` — the
+     * normal controlled-input contract. A `value` that only catches up after a
+     * round-trip leaves the field showing the pre-emit query until it does, and
+     * anything typed while that update is in flight is dropped when it lands.
+     */
+    value?: string;
+    onChange?: (value: string) => void;
+    /**
+     * Debounce before a controlled `onChange` fires, in ms. Default 300.
+     *
+     * `0` (or negative) means no debounce at all — `onChange` fires inline on the
+     * keystroke, with no timer. Use it for search that filters rows already in
+     * memory: a debounce only adds keystroke lag there, and emitting inline also
+     * means the field is never showing a query the parent has not been handed.
+     */
+    debounceMs?: number;
+}
+
+export declare function ProDataTableToolbar({ className, children, }: {
+    className?: string;
+    children?: React_2.ReactNode;
+}): JSX.Element;
+
+export declare function ProgressBar({ value, max, color, className }: ProgressBarProps): JSX.Element;
+
+export declare function ProgressBarCell({ value, total, label, tone, className, }: ProgressBarCellProps): JSX.Element;
+
+declare interface ProgressBarCellProps {
+    value: number;
+    total: number;
+    label?: React_2.ReactNode;
+    /** Tone applied to the fill bar. Defaults to neutral ink. */
+    tone?: 'neutral' | 'running' | 'success' | 'danger';
+    className?: string;
+}
+
+declare interface ProgressBarProps {
+    value: number;
+    max?: number;
+    color?: string;
+    className?: string;
+}
+
+/**
+ * A quiet live/refresh indicator: a small green dot (muted when paused) that
+ * pulses subtly while a refresh is in flight, doubling as a manual-refresh
+ * button. Deliberately text-free — the freshness detail lives in the tooltip so
+ * the UI doesn't churn a ticking label.
+ */
+export declare function RefreshIndicator({ onRefresh, isFetching, isPaused, updatedAt, className, }: RefreshIndicatorProps): JSX.Element;
+
+export declare interface RefreshIndicatorProps {
+    /** Manually trigger a refresh. */
+    onRefresh: () => void;
+    /** A background refresh is in flight — shows a subtle pulse. */
+    isFetching?: boolean;
+    /** Auto-refresh is paused (e.g. while editing) — shows a muted dot. */
+    isPaused?: boolean;
+    /** Last successful refresh time (ms epoch) — surfaced in the tooltip only. */
+    updatedAt?: number;
+    className?: string;
+}
+
+export declare function RelativeTimeCell({ primary, secondary, className, }: {
+    primary: React_2.ReactNode;
+    secondary?: React_2.ReactNode;
+    className?: string;
+}): JSX.Element;
+
+export declare function RequiredMarker({ className }: {
+    className?: string;
+}): JSX.Element;
+
+export declare function ResultsBarCell({ passed, warn, failed, className }: ResultsBarCellProps): JSX.Element;
+
+declare interface ResultsBarCellProps {
+    passed: number;
+    warn?: number;
+    failed?: number;
+    className?: string;
+}
+
+export declare function RouteLoading({ className }: RouteLoadingProps): JSX.Element;
+
+export declare interface RouteLoadingProps {
+    className?: string;
+}
+
+export { Row }
+
+/**
+ * A single entry in a row's overflow (⋯) menu. The consumer resolves these
+ * per-row via `rowActions`, so `onSelect` closes over the row itself — no row
+ * argument needed here.
+ */
+declare interface RowAction {
+    label: React_2.ReactNode;
+    onSelect: () => void;
+    /** Optional leading icon (e.g. `<IconPencil />`). */
+    icon?: React_2.ReactNode;
+    /** Render below a divider with destructive styling (Delete, Remove, …). */
+    destructive?: boolean;
+    disabled?: boolean;
+    /** Omit this action for this row entirely. */
+    hidden?: boolean;
+}
+
+export declare function scoreBand(value: number): 'green' | 'amber' | 'red';
+
+export declare function ScoreBarCell({ value, className, }: {
+    value: number | null | undefined;
+    className?: string;
+}): JSX.Element;
+
+export declare const ScrollArea: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ScrollBar: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Shared search input with a left-aligned magnifying glass icon and an
+ * optional right-aligned clear (×) button. Both icons come from
+ * `lucide-react` — Atlas's primary icon library — and are sized to 14px
+ * to match the h-9 input's optical balance.
+ *
+ * Works in both controlled and uncontrolled modes. In controlled mode,
+ * clicking the clear button synthesizes an `onChange` event with an
+ * empty value using the native setter so React's state pipeline picks
+ * it up correctly. In uncontrolled mode, it clears the input directly.
+ *
+ * The native WebKit/Chromium `::-webkit-search-cancel-button` is
+ * suppressed so consumers see one consistent clear affordance across
+ * browsers, not two stacked ones.
+ */
+export declare const SearchInput: React_2.ForwardRefExoticComponent<SearchInputOwnProps & Omit<Omit<Omit<InputProps_2, "ref"> & React_2.RefAttributes<HTMLInputElement>, "ref">, "type"> & React_2.RefAttributes<HTMLInputElement>>;
+
+declare type SearchInputOwnProps = {
+    /**
+     * Size of the magnifying glass icon in px. Defaults to 14 — matches
+     * the h-9 input height's optical balance.
+     */
+    iconSize?: number;
+    /**
+     * Tailwind classes for the outer relative wrapper (e.g., width / layout).
+     * Use `className` for the actual `<input>` styling.
+     */
+    containerClassName?: string;
+    /**
+     * Optional override for the icon tailwind classes. By default the icon
+     * sits on the LEFT side of the input with enough padding that the first
+     * character of user text never collides with the icon.
+     */
+    iconClassName?: string;
+    /**
+     * Hide the built-in clear (×) button. Defaults to `false`. The clear
+     * button appears when the input has a value and replaces the browser's
+     * inconsistent native `<input type="search">` × with a properly-sized
+     * Lucide X icon that matches the rest of the design system.
+     */
+    hideClearButton?: boolean;
+};
+
+export declare type SearchInputProps = SearchInputOwnProps & Omit<React_2.ComponentPropsWithoutRef<typeof Input>, 'type'>;
+
+export declare function SectionHeader({ title, icon, children, className }: SectionHeaderProps): JSX.Element;
+
+declare interface SectionHeaderProps {
+    title: string;
+    icon?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+
+/**
+ * Inline section loading indicator. Use inside cards, chart areas, sidebar
+ * panels, or any bounded region that loads independently of the page chrome.
+ */
+export declare function SectionLoadingState({ className, size, label }: SectionLoadingStateProps): JSX.Element;
+
+export declare interface SectionLoadingStateProps {
+    className?: string;
+    size?: 'sm' | 'default';
+    label?: string;
+}
+
+export declare function SegmentedControl<T extends string>({ options, value, onChange, className, }: SegmentedControlProps<T>): JSX.Element;
+
+declare interface SegmentedControlOption<T extends string> {
+    value: T;
+    label: string;
+    icon?: ReactNode;
+}
+
+declare interface SegmentedControlProps<T extends string> {
+    options: SegmentedControlOption<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    className?: string;
+}
+
+export declare const Select: React_2.FC<SelectPrimitive.SelectProps>;
+
+export declare const SelectContent: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectGroup: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectItem: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectLabel: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectScrollDownButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectScrollUpButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectSeparator: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectTrigger: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & SelectTriggerOwnProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare interface SelectTriggerOwnProps {
+    /**
+     * Error state — destructive border, destructive focus ring, and
+     * `aria-invalid="true"`. Mirrors `Input` / `Textarea` so the three
+     * form primitives share the same API surface.
+     */
+    error?: boolean | string;
+}
+
+export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const Sheet: React_2.FC<DialogPrimitive.DialogProps>;
+
+export declare const SheetClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const SheetContent: React_2.ForwardRefExoticComponent<SheetContentProps & React_2.RefAttributes<HTMLDivElement>>;
+
+declare interface SheetContentProps extends React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+    hideCloseButton?: boolean;
+}
+
+export declare const SheetDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const SheetFooter: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const SheetHeader: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const SheetOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare function SheetPortal({ container, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Portal>): JSX.Element;
+
+export declare const SheetTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare const SheetTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare const sheetVariants: (props?: ({
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+/**
+ * Whether a field should render as an inline chip on the row, given its
+ * `show` config and whether it currently holds a value. The right-click menu
+ * is unaffected by this — it always lists every field.
+ */
+export declare function showFieldInline({ show, hasValue, }: {
+    show?: TaskFieldShow;
+    hasValue: boolean;
+}): boolean;
+
+/**
+ * SingleSelectList — the single-select sibling of `MultiSelectList`. Same
+ * searchable cmdk body, pinned grouping, and icon column, but rows carry a
+ * leading checkmark (not a checkbox) and selecting one replaces the value.
+ * Use this for single-choice facets in a shared `FilterMenu` so they read as
+ * a proper select list rather than a radio-dot menu.
+ */
+export declare function SingleSelectList({ options, value, onChange, searchPlaceholder, emptyMessage, clearable, hideSelectedIndicator, selectedIndicatorSide, query, onQueryChange, className, searchable, }: SingleSelectListProps): JSX.Element;
+
+declare interface SingleSelectListProps {
+    options: MultiSelectOption[];
+    /** Currently selected value, or null when nothing is chosen. */
+    value: string | null;
+    onChange: (value: string | null) => void;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    /** Clicking the already-selected row clears it back to null. Default true. */
+    clearable?: boolean;
+    /**
+     * Drop the leading checkmark column. Use for action-style pickers that never
+     * persist a selection (e.g. a reassign list), where the always-empty check
+     * gutter just reads as dead left padding. Default false (checkmark shown).
+     */
+    hideSelectedIndicator?: boolean;
+    /**
+     * Which side of the row the selected checkmark sits on. Default 'left' (the
+     * leading-checkmark select pattern). Use 'right' for menu-style lists where
+     * the label should read flush-left and the tick trails it.
+     */
+    selectedIndicatorSide?: 'left' | 'right';
+    /** Controlled search query. Omit to let the list manage its own. */
+    query?: string;
+    onQueryChange?: (query: string) => void;
+    className?: string;
+    /** Show the search input. Default true (see `SelectListShellProps`). */
+    searchable?: boolean;
+}
+
+export declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): JSX.Element;
+
+export declare function SkeletonBlock({ className, style }: {
+    className?: string;
+    style?: React.CSSProperties;
+}): JSX.Element;
+
+export declare const Slider: React_2.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare function SortableHeader({ column, children }: {
+    column: any;
+    children: React.ReactNode;
+}): JSX.Element;
+
+export { SortingState }
+
+export declare function SparklineCell({ values, highlightTail, label, width, height, scaleMax, className, }: SparklineCellProps): JSX.Element;
+
+declare interface SparklineCellProps {
+    values: number[];
+    /** Highlight a trailing portion in rose (e.g. failures near end). */
+    highlightTail?: number;
+    label?: React_2.ReactNode;
+    /** Fixed pixel width of the sparkline area. */
+    width?: number;
+    height?: number;
+    /** When set, bar heights use this fixed max instead of scaling to the series peak. */
+    scaleMax?: number;
+    className?: string;
+}
+
+export declare function Spinner({ size, className, ...props }: VariantProps<typeof spinnerVariants> & React.ComponentProps<'div'>): JSX.Element;
+
+export declare const spinnerVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const STATUS_TONES: {
+    readonly healthy: {
+        readonly bg: "bg-emerald-50 dark:bg-emerald-500/15";
+        readonly fg: "text-emerald-700 dark:text-emerald-300";
+        readonly dot: "bg-emerald-500";
+    };
+    readonly active: {
+        readonly bg: "bg-emerald-50 dark:bg-emerald-500/15";
+        readonly fg: "text-emerald-700 dark:text-emerald-300";
+        readonly dot: "bg-emerald-500";
+    };
+    readonly completed: {
+        readonly bg: "bg-emerald-50 dark:bg-emerald-500/15";
+        readonly fg: "text-emerald-700 dark:text-emerald-300";
+        readonly dot: "bg-emerald-500";
+    };
+    readonly success: {
+        readonly bg: "bg-emerald-50 dark:bg-emerald-500/15";
+        readonly fg: "text-emerald-700 dark:text-emerald-300";
+        readonly dot: "bg-emerald-500";
+    };
+    readonly running: {
+        readonly bg: "bg-sky-50 dark:bg-sky-500/15";
+        readonly fg: "text-sky-700 dark:text-sky-300";
+        readonly dot: "bg-sky-500";
+    };
+    readonly info: {
+        readonly bg: "bg-sky-50 dark:bg-sky-500/15";
+        readonly fg: "text-sky-700 dark:text-sky-300";
+        readonly dot: "bg-sky-500";
+    };
+    readonly queued: {
+        readonly bg: "bg-sky-50 dark:bg-sky-500/15";
+        readonly fg: "text-sky-700 dark:text-sky-300";
+        readonly dot: "bg-sky-500";
+    };
+    readonly drift: {
+        readonly bg: "bg-amber-50 dark:bg-amber-500/15";
+        readonly fg: "text-amber-700 dark:text-amber-300";
+        readonly dot: "bg-amber-500";
+    };
+    readonly warn: {
+        readonly bg: "bg-amber-50 dark:bg-amber-500/15";
+        readonly fg: "text-amber-700 dark:text-amber-300";
+        readonly dot: "bg-amber-500";
+    };
+    readonly failing: {
+        readonly bg: "bg-rose-50 dark:bg-rose-500/15";
+        readonly fg: "text-rose-700 dark:text-rose-300";
+        readonly dot: "bg-rose-500";
+    };
+    readonly failed: {
+        readonly bg: "bg-rose-50 dark:bg-rose-500/15";
+        readonly fg: "text-rose-700 dark:text-rose-300";
+        readonly dot: "bg-rose-500";
+    };
+    readonly error: {
+        readonly bg: "bg-rose-50 dark:bg-rose-500/15";
+        readonly fg: "text-rose-700 dark:text-rose-300";
+        readonly dot: "bg-rose-500";
+    };
+    readonly paused: {
+        readonly bg: "bg-muted";
+        readonly fg: "text-muted-foreground";
+        readonly dot: "bg-muted-foreground";
+    };
+    readonly neutral: {
+        readonly bg: "bg-muted";
+        readonly fg: "text-muted-foreground";
+        readonly dot: "bg-muted-foreground";
+    };
+};
+
+/** Sort rank within a board order (unknown statuses sort last). */
+export declare function statusBoardRankIn(order: readonly string[], status: string): number;
+
+export declare function StatusDotBadge({ tone, label, pulse, className, }: {
+    tone: StatusTone;
+    label: React_2.ReactNode;
+    pulse?: boolean;
+    className?: string;
+}): JSX.Element;
+
+/** Resolve a status's display meta within a vocabulary, with a neutral fallback. */
+export declare function statusMetaOf(options: TaskStatusOption[], value: string): TaskStatusOption;
+
+/** Render a status vocabulary as `SingleSelectList` options (glyph + label). */
+export declare function statusSelectOptions(options: TaskStatusOption[]): MultiSelectOption[];
+
+export declare type StatusTone = keyof typeof STATUS_TONES;
+
+/**
+ * Switch — slider-style on/off toggle.
+ *
+ * No drop shadows — neither on the track nor the thumb — consistent
+ * with the rest of Atlas's form primitives (Input, Select, Textarea,
+ * Button, Checkbox). Affordance comes from the bg-color transition
+ * (`bg-input` → `bg-primary`) and the thumb's translate + opaque
+ * contrast against the track.
+ */
+export declare const Switch: React_2.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const Table: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableElement> & React_2.RefAttributes<HTMLTableElement>>;
+
+export declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;
+
+export declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+
+export declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+
+export declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;
+
+export declare const Tabs: React_2.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const TabsContent: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const TabsList: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "line" | "sidebar" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const TabsTrigger: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+/** Assignee field config — visibility/edit plus the options the inline picker offers. */
+export declare interface TaskAssigneeConfig extends TaskFieldConfig {
+    options?: TaskAssigneeOption[];
+}
+
+/** One selectable assignee in the single-select picker. */
+export declare interface TaskAssigneeOption {
+    /** Identity persisted on the task (`ownerEmail`). */
+    email: string;
+    /** Display name; falls back to the email stem. */
+    name?: string;
+    /** Two-letter avatar initials; derived from email when omitted. */
+    initials?: string;
+}
+
+export declare function TaskCreateDialog({ open, onOpenChange, initialValues, assigneeOptions, statusOptions, defaultStatus, showDescription, createFields, initialFieldValues, onCreate, }: TaskCreateDialogProps): JSX.Element;
+
+export declare interface TaskCreateDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Seeds the form when the dialog opens (status / owner / due from a group). */
+    initialValues?: Partial<TaskRowData>;
+    /** People offered by the assignee picker. Omit to hide the assignee field. */
+    assigneeOptions?: TaskAssigneeOption[];
+    /** Status vocabulary for the status picker. Defaults to the built-in set. */
+    statusOptions?: TaskStatusOption[];
+    /** Status a fresh draft seeds with (the incomplete status). Default `'todo'`. */
+    defaultStatus?: string;
+    /**
+     * Show the long-form description field. Default `true`. Set `false` for task
+     * surfaces with no description concept (or that never display one), so the
+     * create flow doesn't collect a field the list can't show.
+     */
+    showDescription?: boolean;
+    /** Extra single-select fields (e.g. Category). */
+    createFields?: TaskCreateField[];
+    /** Seeds for the extra fields, keyed by field id (matched by value or label). */
+    initialFieldValues?: TaskCreateFieldValues;
+    /** Builds + commits the new task. */
+    onCreate: (draft: TaskRowData, fieldValues: TaskCreateFieldValues) => void;
+}
+
+/** A consumer-defined extra single-select on the create dialog (e.g. Category). */
+export declare interface TaskCreateField {
+    id: string;
+    label: string;
+    options: MultiSelectOption[];
+    /** Block the create action until this field has a value. */
+    required?: boolean;
+}
+
+/** Values chosen for the extra `createFields`, keyed by field id. */
+export declare type TaskCreateFieldValues = Record<string, string | null>;
+
+/**
+ * The single, uniform chip every inline task field renders through. Squared-
+ * rounded and the same height as the design system's `Badge`, with a
+ * consistent empty-state. Use `asStatic` for display-only (edit: 'menu')
+ * fields and the interactive `<button>` form for inline editors.
+ */
+export declare const TaskFieldChip: React_2.ForwardRefExoticComponent<Omit<TaskFieldChipProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare interface TaskFieldChipProps extends React_2.ComponentProps<'button'> {
+    /** Leading icon (kept small + muted by the chip). */
+    icon?: React_2.ReactNode;
+    /** Empty-state styling — dashed, muted — for an `always`-shown unset field. */
+    empty?: boolean;
+    /** Tonal treatment for value-carrying chips (e.g. overdue due date). */
+    tone?: TaskFieldChipTone;
+    /** Renders as a static span (no button affordance) for display-only fields. */
+    asStatic?: boolean;
+}
+
+export declare type TaskFieldChipTone = keyof typeof CHIP_TONES;
+
+/** Per-field display + edit configuration. */
+export declare interface TaskFieldConfig {
+    /** When the field shows inline. Defaults to `'whenSet'`. */
+    show?: TaskFieldShow;
+    /** How the field is edited. Defaults to `'inline'`. */
+    edit?: TaskFieldEdit;
+}
+
+/**
+ * A declarative custom field rendered on the row's second line. Built-in
+ * fields (due / assignee / tags) have named props on `TaskRow`; this is the
+ * escape hatch for everything else (workstream, goal, experiment, priority,
+ * project, estimate, …). Compose the value with the opinionated chip
+ * components exported from this module so custom fields match the built-ins.
+ *
+ * ## Editable by default
+ *
+ * A shown field is INLINE-EDITABLE by default — exactly like the assignee:
+ * declare `options` + `onChange` and TaskRow renders an interactive chip that
+ * opens the shared `SingleSelectList` picker anchored to the chip. A field is
+ * display-only ONLY when it explicitly opts out (`readOnly: true`) or supplies
+ * no editor (`options`/`onChange`), or when it provides a bespoke `render`
+ * (the static escape hatch). This keeps "shown ⇒ editable unless explicitly
+ * read-only" true across every field, not just the named ones.
+ */
+export declare interface TaskFieldDef {
+    /** Stable key (React key + menu identity). */
+    id: string;
+    /** Human label — the right-click menu entry and the editor's search hint. */
+    label: string;
+    show?: TaskFieldShow;
+    edit?: TaskFieldEdit;
+    /** Does the field currently hold a value? Drives `show: 'whenSet'`. */
+    hasValue: boolean;
+    /**
+     * Bespoke inline chip content (the static escape hatch). Optional — when
+     * omitted, TaskRow renders a uniform `TaskFieldChip` from `icon` + `text`
+     * (interactive when `options`/`onChange` are present and not `readOnly`,
+     * static otherwise). Providing `render` always yields a static chip; use it
+     * only when the opinionated chip can't express the content.
+     */
+    render?: () => React_2.ReactNode;
+    /**
+     * A value standing in for `render`'s output for memo comparison. When a row
+     * is memoized, the bespoke `render` output is opaque to the equality check —
+     * so a render-backed field is treated as changed unless it supplies a
+     * `renderKey` that matches the previous one (set it to whatever the render
+     * reads, e.g. the priority string). Without a `renderKey`, a render-backed
+     * field always re-renders (correct but unmemoized).
+     */
+    renderKey?: string;
+    /** Leading glyph for the auto-rendered chip. */
+    icon?: React_2.ReactNode;
+    /** Tonal treatment for the auto-rendered chip. Defaults to `'default'`. */
+    tone?: TaskFieldChipTone;
+    /** Display text for the auto-rendered chip. Falls back to a string `value`. */
+    text?: string;
+    /**
+     * Choices for the inline single-select editor. With `onChange` (and without
+     * `readOnly`/`render`) this makes the field editable — the chip becomes a
+     * button that opens the shared picker, same as the assignee.
+     */
+    options?: MultiSelectOption[];
+    /** Inline-editor write handler. `null` = the value was cleared/unset. */
+    onChange?: (value: string | null) => void;
+    /**
+     * The editor's currently-selected option value, when it differs from the
+     * displayed `value` — e.g. the chip shows an experiment's *label* but the
+     * options are keyed by its *id*. Falls back to `value` when omitted.
+     */
+    editorValue?: string | null;
+    /** Explicitly make the field display-only, even if it carries an editor. */
+    readOnly?: boolean;
+    /** Placeholder for the inline editor's search box. Defaults to `label`. */
+    editorPlaceholder?: string;
+    /**
+     * Whether clicking the selected option clears it (`onChange(null)`).
+     * Defaults to `true`. Set `false` for fields the backend won't let you
+     * unset (e.g. a required enum).
+     */
+    editorClearable?: boolean;
+    /** Invoked when the field is chosen from the right-click menu (advanced). */
+    onEditFromMenu?: () => void;
+    /**
+     * Raw value(s) used for filtering. When present (and `filterable` isn't
+     * `false`), the list's `filterable` automatically derives a filter facet
+     * from this field — keyed by `id`, labeled by `label`, with options
+     * collected from the distinct values across the tasks. So declaring a
+     * field is enough to make it both a chip and a facet.
+     */
+    value?: string | string[];
+    /** Opt this field out of becoming a filter facet even when it has a value. */
+    filterable?: boolean;
+}
+
+/** How a field is edited: an inline editor, or only via the right-click menu. */
+export declare type TaskFieldEdit = 'inline' | 'menu';
+
+/** When a field appears as an inline chip on the row. */
+export declare type TaskFieldShow = 'always' | 'whenSet' | 'never';
+
+export declare function TaskList<T extends TaskListItem>({ tasks, editable, statusOnly, hideOwner, getRowKey, onChange, createTask, onTaskUpdate, onTaskDelete, onTaskCreate, emptyMessage, searchable, filterable, currentUserEmail, onVisibleTasksChange, groupable, defaultGroupBy, groupStorageKey, due, assignee, tags, fields, createFields, statusOptions, statusBoardOrder, completeStatus, incompleteStatus, startStatus, resolvedStatuses, showDescription, className, }: TaskListProps<T>): JSX.Element;
+
+/** Minimal item shape — the `TaskRow` presentation fields plus whatever the consumer carries. */
+export declare type TaskListItem = TaskRowData & {
+    id?: string;
+};
+
+export declare interface TaskListProps<T extends TaskListItem> {
+    tasks: T[];
+    /**
+     * Read-only when false: no inline editing, no draft row, no delete. Pair
+     * with omitting `onChange` for a pure display list.
+     */
+    editable?: boolean;
+    /**
+     * Lock everything except the status circle (rollup surfaces). Title is
+     * static, due pill hidden, no draft row, no delete. `editable` must still
+     * be true for the status control to open.
+     */
+    statusOnly?: boolean;
+    /** Suppress the owner avatar on every row (single-owner surfaces). */
+    hideOwner?: boolean;
+    /** Stable React key per row. Defaults to the array index. */
+    getRowKey?: (task: T, index: number) => string;
+    /**
+     * Fires with the full next list on any create / edit / delete. Use this
+     * for in-memory lists the parent holds in state. For cache-backed lists
+     * (React Query, per-row server mutations) prefer the granular
+     * `onTask*` callbacks below — they fire per row and don't require the
+     * parent to own the whole array.
+     */
+    onChange?: (tasks: T[]) => void;
+    /**
+     * Build a full task from a committed draft row. Used with `onChange` to
+     * surface the draft "add a task" slot. The consumer stamps id / owner
+     * defaults / timestamps here. Ignored when `onTaskCreate` is provided.
+     */
+    createTask?: (draft: TaskRowData) => T;
+    /** Granular: a single row's fields changed (status / title / due / …). */
+    onTaskUpdate?: (task: T, patch: Partial<TaskRowData>) => void;
+    /** Granular: a single row was deleted. */
+    onTaskDelete?: (task: T) => void;
+    /**
+     * Granular: a new task was created via the create dialog. Enables the
+     * per-group "Add task" affordance. `fieldValues` carries the chosen values
+     * for any `createFields` (e.g. category), seeded from the originating group.
+     */
+    onTaskCreate?: (draft: TaskRowData, fieldValues?: TaskCreateFieldValues) => void;
+    /** Shown when the list is empty and read-only. */
+    emptyMessage?: React_2.ReactNode;
+    /**
+     * Built-in search input above the list. `true` for defaults (matches
+     * title + tags + owner), or an object to customize placeholder / matcher.
+     */
+    searchable?: TaskListSearchable<T>;
+    /**
+     * Built-in faceted filter (shared `FilterMenu`). When on, EVERY available
+     * facet becomes filterable: Status, Assignee (when `assignee.options` is
+     * set), Tags (from the data), AND every custom `fields` entry that carries
+     * a `value`. No need to re-declare facets — declaring a field is enough.
+     */
+    filterable?: boolean;
+    /**
+     * The signed-in user's email. When set, the toolbar shows a "My Tasks"
+     * quick-filter toggle that narrows the list to tasks owned by this user.
+     */
+    currentUserEmail?: string;
+    /**
+     * Fires with the post-search / post-filter / post-"My Tasks" visible set
+     * whenever it changes. The list owns those controls internally, so a
+     * consumer that needs the live visible scope (e.g. publishing a Jarvis
+     * chat-view snapshot) can't derive it from `tasks` — this surfaces it.
+     */
+    onVisibleTasksChange?: (visible: T[]) => void;
+    /**
+     * Offer Linear-style grouping: a toolbar control to group rows under
+     * collapsible headers by any available field. On by default (the control
+     * shows), but grouping itself starts OFF — see `defaultGroupBy`. `false`
+     * hides the control entirely. Auto-disabled in `statusOnly` mode.
+     */
+    groupable?: boolean;
+    /**
+     * Initial grouping dimension key. Defaults to `'none'` (flat list, still
+     * board-sorted) — grouping is opt-in. Pass `'status'` (etc.) for a surface
+     * that should start grouped.
+     */
+    defaultGroupBy?: string;
+    /**
+     * Persist collapsed groups (and the chosen grouping dimension) across
+     * reloads under this localStorage key — Linear-style sticky groups. Omit for
+     * ephemeral, per-mount state.
+     */
+    groupStorageKey?: string;
+    /** Due-date field config, forwarded to every row. See `TaskRow`. */
+    due?: TaskFieldConfig;
+    /** Assignee field config + options, forwarded to every row. See `TaskRow`. */
+    assignee?: TaskAssigneeConfig;
+    /** Tags field config, forwarded to every row. See `TaskRow`. */
+    tags?: TaskFieldConfig;
+    /** Per-row custom fields builder — called for each task to build its chips. */
+    fields?: (task: T) => TaskFieldDef[];
+    /**
+     * Status vocabulary + interaction mapping, forwarded to every row and used
+     * for the status group/filter dimension and the board sort. All default to
+     * the built-in set, so a surface with the standard statuses passes nothing.
+     * Pass stable references (module consts / memoized) — rows compare them by
+     * identity.
+     */
+    statusOptions?: TaskStatusOption[];
+    /** Status sort/group order (board: active first). Defaults to the built-in board order. */
+    statusBoardOrder?: readonly string[];
+    /** Checkbox "checked" / "unchecked" targets. Default `'done'` / `'todo'`. */
+    completeStatus?: string;
+    incompleteStatus?: string;
+    /** Hover "Start" button target (shown at the incomplete status). Default `'in_progress'`; `null` hides it. */
+    startStatus?: string | null;
+    /** Statuses treated as resolved (struck-through + no due urgency). Default `['done','cancelled']`. */
+    resolvedStatuses?: readonly string[];
+    /**
+     * Show the long-form description field in the create dialog. Default `true`.
+     * Set `false` for surfaces with no description concept (or that never display
+     * one) so the create flow doesn't collect a field the list can't show.
+     */
+    showDescription?: boolean;
+    /**
+     * Extra single-select fields shown in the create dialog (e.g. Category).
+     * A required field gates "Create". When the list is grouped by a dimension
+     * whose key matches a field id, that field is pre-seeded from the group.
+     */
+    createFields?: TaskCreateField[];
+    className?: string;
+}
+
+/** Built-in search config. `true` = default search over title + tags + owner. */
+export declare type TaskListSearchable<T> = boolean | {
+    placeholder?: string;
+    /** Custom searchable text for a task. Defaults to title + tags + owner. */
+    accessor?: (task: T) => string;
+};
+
+export declare const TaskRow: React_2.NamedExoticComponent<TaskRowProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface TaskRowData {
+    title: string;
+    status: TaskRowStatus;
+    /** Long-form body. Not rendered on the row — carried for the create dialog. */
+    description?: string | null;
+    /** ISO YYYY-MM-DD. Null / undefined for tasks with no due date. */
+    dueDate?: string | null;
+    /** Used to color + initial the owner avatar. Null for unassigned. */
+    ownerEmail?: string | null;
+    ownerInitials?: string | null;
+    /** Freeform labels rendered as chips on the row's second line. */
+    tags?: string[];
+}
+
+export declare interface TaskRowProps {
+    /**
+     * Current row data. Pass `null` for a placeholder/draft row — the
+     * row renders idle styling + placeholder copy until the user
+     * starts typing.
+     */
+    task: TaskRowData | null;
+    /**
+     * Read-only when false. Status / title / due / owner / linear /
+     * delete affordances are all suppressed. Useful for preview
+     * surfaces (popovers, drawers).
+     */
+    editable?: boolean;
+    /**
+     * Default placeholder for the title input. Defaults to a generic
+     * prompt; surfaces with stronger context (e.g. "this week's goal")
+     * should pass something more specific.
+     */
+    placeholder?: string;
+    /**
+     * Fires on every field change (status, due, etc.) for committed
+     * rows. NOT called for draft rows — the draft fires `onCommit`
+     * once the user types a title. Receives a partial patch; merge
+     * with the existing row at the call site.
+     */
+    onChange?: (patch: Partial<TaskRowData>) => void;
+    /**
+     * Called when a draft row commits (user types a non-empty title
+     * and blurs / hits Enter). The parent typically appends the new
+     * task to its list and renders a fresh draft TaskRow at the end.
+     */
+    onCommit?: (next: TaskRowData) => void;
+    /**
+     * Delete handler. When omitted, both the right-click context menu
+     * item and any visible delete affordance are suppressed.
+     */
+    onDelete?: () => void;
+    /**
+     * Suppress the owner avatar regardless of `ownerEmail`. Used by
+     * surfaces where every row is already implicitly scoped to the
+     * caller (MyWeek's per-card task list — every card and task on it
+     * belongs to the signed-in user, so repeating the same JJ pip on
+     * every row is pure chrome). The avatar still renders by default;
+     * surfaces with mixed-owner task lists (Tasks tab, HypothesisDetail)
+     * leave this off.
+     */
+    hideOwner?: boolean;
+    /**
+     * Lock everything except the status circle. The title renders as
+     * static text (not an input), the due-date pill is hidden, the
+     * right-click delete is suppressed. Used by rollup surfaces (e.g.
+     * AllMembersTab) where viewers can move work forward but can't
+     * authoring-edit someone else's task from there. `editable` must
+     * still be true for the status dropdown to open.
+     */
+    statusOnly?: boolean;
+    /**
+     * Due-date field config. Defaults to `{ show: 'whenSet', edit: 'inline' }`.
+     * Set `{ show: 'whenSet', edit: 'menu' }` for the "only via right-click,
+     * only shown once set" pattern. See the UX contract in `task-field.tsx`.
+     */
+    due?: TaskFieldConfig;
+    /**
+     * Assignee field config + the options the inline single-select offers.
+     * Defaults to `{ show: 'whenSet', edit: 'inline' }`. With `show: 'always'`
+     * an unassigned task shows an empty-state avatar that opens the picker.
+     * Changing the assignee fires `onChange({ ownerEmail })`.
+     */
+    assignee?: TaskAssigneeConfig;
+    /**
+     * Tags field config (display-only chips on the second line). Defaults to
+     * `{ show: 'whenSet' }`.
+     */
+    tags?: TaskFieldConfig;
+    /**
+     * Declarative custom fields rendered on the second line (priority,
+     * project, estimate, …). Each composes the shared `TaskFieldChip`, so it
+     * matches the built-in fields. Every field also appears in the right-click
+     * menu via `onEditFromMenu`.
+     */
+    fields?: TaskFieldDef[];
+    /**
+     * Status vocabulary — the value/label/icon/tone for every status this row
+     * can show. Defaults to the built-in set (`DEFAULT_STATUS_OPTIONS`). Pass a
+     * stable reference (module const or memoized) — it's compared by identity.
+     */
+    statusOptions?: TaskStatusOption[];
+    /**
+     * Checkbox interaction: clicking the leading circle on a non-complete row
+     * sets `completeStatus`; clicking a complete row resets to `incompleteStatus`.
+     * Default `'done'` / `'todo'`.
+     */
+    completeStatus?: string;
+    incompleteStatus?: string;
+    /**
+     * The status the hover "Start" button transitions to — shown only when the
+     * row sits at `incompleteStatus`. Default `'in_progress'`; pass `null` to
+     * hide the Start affordance entirely.
+     */
+    startStatus?: string | null;
+    /**
+     * Statuses treated as resolved: the title renders struck-through and due-date
+     * urgency is suppressed. Defaults to `['done', 'cancelled']`. Pass a stable
+     * reference — compared by identity.
+     */
+    resolvedStatuses?: readonly string[];
+    className?: string;
+}
+
+export declare type TaskRowStatus = string;
+
+export declare function TaskStatusIndicator({ status, editable, onChange, size, className, statusOptions, }: TaskStatusIndicatorProps): JSX.Element;
+
+export declare interface TaskStatusIndicatorProps {
+    status: TaskRowStatus;
+    /** When false, renders only the colored icon — no click target. */
+    editable?: boolean;
+    onChange?: (next: TaskRowStatus) => void;
+    /** Icon size in px. Defaults to 16. */
+    size?: number;
+    className?: string;
+    /** Status vocabulary. Defaults to the built-in set. */
+    statusOptions?: TaskStatusOption[];
+}
+
+/** One status in a task vocabulary: its value, label, glyph, and icon tone. */
+export declare interface TaskStatusOption {
+    value: string;
+    label: string;
+    /** Glyph for the status circle + picker row. */
+    icon: React_2.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    /** Tailwind text-color class for the glyph, e.g. `'text-blue-600'`. */
+    tone: string;
+}
+
+export declare const Textarea: React_2.ForwardRefExoticComponent<Omit<TextareaProps, "ref"> & React_2.RefAttributes<HTMLTextAreaElement>>;
+
+declare interface TextareaOwnProps {
+    /**
+     * Error state — destructive border, destructive focus ring, and
+     * `aria-invalid="true"`. Mirrors `Input`'s `error` prop so the three
+     * form primitives share the same API surface.
+     */
+    error?: boolean | string;
+}
+
+export declare type TextareaProps = React_2.ComponentProps<"textarea"> & TextareaOwnProps;
+
+/**
+ * shadcn/ui chart primitive (recharts-based).
+ *
+ * Provides a themeable container + tooltip/legend chrome so charts across
+ * Atlas share one styling contract instead of each app hand-rolling recharts
+ * markup. New charts should compose `ChartContainer` + a `ChartConfig` and let
+ * this primitive resolve colors from the `--chart-*` design tokens.
+ *
+ * Jarvis is migrating its bespoke recharts usage onto this primitive — prefer
+ * it over importing recharts directly in new code.
+ */
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+
+export declare function tintForString(seed: string): AgentTint;
+
+export { toast }
+
+/**
+ * Toaster — the Atlas-themed Sonner renderer. Canonical toast system
+ * for the design system, matching the current shadcn recommendation
+ * (https://ui.shadcn.com/docs/components/sonner — the Radix-based
+ * Toast was deprecated in v5 in favor of Sonner).
+ *
+ * Mount once at the app shell — Atlas already does this in
+ * `atlas/src/platform/app/AppLayout.tsx`. Callers never render
+ * `<Toaster />` themselves; they just call `toast(...)` from
+ * 'sonner' and messages appear in the shared stack.
+ *
+ * Why a wrapper instead of using Sonner's `<Toaster>` directly:
+ *   1. Bakes in Atlas's positioning / visibility / sizing defaults
+ *      (top-right, 380px wide, 8-deep stack) so every mount looks
+ *      the same without re-specifying options at the call site.
+ *   2. Binds Sonner's internal classes to Atlas design tokens via
+ *      `toastOptions.classNames` — `bg-card`, `border-border`,
+ *      `shadow-popover`, `rounded-md`, and the `--destructive` /
+ *      `--primary` / `--muted` pairs. Matches Dialog / Popover /
+ *      DropdownMenu so all floating UI reads as one visual family.
+ *   3. Uses `richColors` for the semantic variants
+ *      (`toast.success` / `.error` / `.warning` / `.info`), so
+ *      consumers get Atlas's destructive red on errors without
+ *      per-call styling.
+ *
+ * Usage:
+ *   import { toast } from 'sonner'
+ *
+ *   toast('Saved')
+ *   toast.success('Published')
+ *   toast.error('Upload failed', { description: err.message })
+ *   toast.promise(saveDraft(), {
+ *     loading: 'Saving…',
+ *     success: 'Saved',
+ *     error: (err) => `Failed: ${err.message}`,
+ *   })
+ *   toast('Deleted', {
+ *     description: '3 items moved to trash.',
+ *     action: { label: 'Undo', onClick: () => restore() },
+ *   })
+ */
+export declare function Toaster({ ...props }: ToasterProps): JSX.Element;
+
+export declare const Toggle: React_2.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const ToggleGroup: React_2.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React_2.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string>) & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ToggleGroupItem: React_2.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Toggle — pressable two-state button primitive (shadcn/ui).
+ *
+ * Use for formatting-style toolbars (bold/italic), view-mode switches, or any
+ * button that represents an on/off state without a label. For slider-style
+ * on/off switches in forms, use `Switch` instead. For mutually-exclusive
+ * groups of toggles (segmented picker), use `ToggleGroup`.
+ */
+export declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;
+
+/**
+ * Raw access to Radix's `Arrow` primitive for the rare case where a
+ * consumer wants to render a custom-styled arrow separately from the
+ * default one baked into `TooltipContent`. Most callers should NOT
+ * need this — reach for it only when building a specialized tooltip
+ * variant inside a subsystem (e.g. an inline annotation overlay).
+ */
+export declare const TooltipArrow: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React_2.RefAttributes<SVGSVGElement>>;
+
+export declare const TooltipContent: React_2.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    /**
+     * Per-instance portal container override. Radix Popper uses
+     * `position: fixed` for the tooltip body, which is normally
+     * anchored to the viewport — but per CSS spec, **any** ancestor
+     * with `transform`, `filter`, `perspective`, `will-change`, or
+     * `contain` creates a new containing block and re-anchors fixed
+     * descendants to itself. Surfaces that mount inside such an
+     * ancestor (e.g. a React Flow node body) get tooltips placed at
+     * the wrong viewport position even though Floating UI's math is
+     * correct.
+     *
+     * The shared `PortalContainerProvider` can pick up such a
+     * containing block when the app's outer chrome is transformed.
+     * Pass `container={null}` on triggers inside transformed wrappers
+     * to force the portal back to `document.body`, where no
+     * transformed ancestor can re-anchor `position: fixed`.
+     *
+     * Leave undefined to inherit `usePortalContainer()` (default).
+     */
+    container?: HTMLElement | null;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+declare type TooltipPayloadItem = {
+    name?: string | number;
+    dataKey?: string | number;
+    value?: number | string;
+    color?: string;
+    payload?: Record<string, unknown>;
+    fill?: string;
+};
+
+/**
+ * Tooltip — contextual helper text anchored to a trigger.
+ *
+ * Wraps Radix's Tooltip primitives with Atlas defaults. The component
+ * family tracks shadcn's canonical v5 pattern:
+ *
+ *   - `TooltipProvider` is mounted once at the app shell
+ *     (`atlas/src/platform/app/AppLayout.tsx`) with
+ *     `delayDuration={200}` — consumers don't need to provide their own.
+ *   - `TooltipContent` renders into the shared portal container
+ *     (`usePortalContainer()`) so tooltips escape `overflow: hidden`
+ *     ancestors (tables, scroll regions, dialogs) and still align to
+ *     the trigger correctly.
+ *   - `TooltipArrow` is baked into `TooltipContent` — the caret
+ *     pointing at the trigger is an expected affordance, not an opt-in
+ *     one.
+ *   - Colors use `bg-foreground` / `text-background` (neutral dark
+ *     tooltip on light surfaces). Intentionally NOT `bg-primary` —
+ *     tooltips are informational, not branded; using the primary
+ *     color made them read as popovers or links in themed apps.
+ *
+ * Usage:
+ * ```tsx
+ * <Tooltip>
+ *   <TooltipTrigger asChild>
+ *     <Button variant="ghost" size="icon">
+ *       <Info />
+ *     </Button>
+ *   </TooltipTrigger>
+ *   <TooltipContent>Helpful description</TooltipContent>
+ * </Tooltip>
+ * ```
+ *
+ * For triggers that are a single non-interactive element (text span,
+ * icon), wrap with `asChild` so the trigger inherits the child's DOM
+ * rather than adding an extra button wrapper.
+ */
+export declare const TooltipProvider: React_2.FC<TooltipPrimitive.TooltipProviderProps>;
+
+export declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare function TrendBadge({ value, invertColors }: TrendBadgeProps): JSX.Element;
+
+declare interface TrendBadgeProps {
+    value: number | null;
+    /** When true, "up" is green (revenue). Default false: "up" is red (cost). */
+    invertColors?: boolean;
+}
+
+/**
+ * Text that truncates with an ellipsis and reveals its full value in a tooltip —
+ * **but only when actually clipped**. The one place the overflow-detection +
+ * tooltip pattern lives, so every truncating title/label gets it for free.
+ *
+ * Use for **titles and labels** (page/tab titles, table cells, breadcrumbs, list
+ * rows) — anything single-line that must fit a bounded width. Do **not** use for
+ * body or long-form copy: that should wrap, not truncate.
+ *
+ * ```tsx
+ * <TruncatedText className="max-w-[16rem]">{customer.name}</TruncatedText>
+ *
+ * // asChild — the link itself truncates; pass the text as `tooltip`:
+ * <TruncatedText asChild tooltip={repo.name}>
+ *   <a href={href} className="max-w-[14rem]">{repo.name}</a>
+ * </TruncatedText>
+ * ```
+ */
+export declare function TruncatedText({ asChild, tooltip, side, className, children, ref: forwardedRef, ...props }: TruncatedTextProps): JSX.Element;
+
+declare type TruncatedTextProps = ComponentProps<'span'> & {
+    /**
+     * Merge the truncation + tooltip onto the child element instead of rendering a
+     * `<span>` (shadcn `asChild`). Use when the truncating element must be a link,
+     * button, or heading. When set, pass `tooltip` explicitly — `children` is an
+     * element, not the text.
+     */
+    asChild?: boolean;
+    /** Tooltip content. Defaults to `children` (correct only when they're the raw
+     *  text — i.e. not `asChild`). */
+    tooltip?: ReactNode;
+    /** Tooltip side; forwarded to `TooltipContent`. */
+    side?: ComponentProps<typeof TooltipContent>['side'];
+};
+
+export declare function useAppClassName(): string | undefined;
+
+/**
+ * Owns the "don't clobber the in-progress edit" draft pattern.
+ *
+ * A click-to-edit control mirrors a server/parent `value` into local state, but
+ * a background refresh or parent re-render that arrives MID-EDIT must not
+ * overwrite what the user is typing. This hook resyncs the draft from `value`
+ * only while `editing` is false; while editing, the draft is left alone.
+ *
+ * `value` must be the STABLE source (typically the prop/cache object), not a
+ * value recomputed every render — the resync watches `value` by identity. Use
+ * `toDraft` to derive the draft shape from a stable source (e.g. project a
+ * workstream object to one side's owner rows); the mapper is read from a ref so
+ * passing an inline closure doesn't trigger spurious resyncs.
+ *
+ * Extracted from `inline-text-cell.tsx`; the shared layer for every inline
+ * editor (text cells, owner pickers, date cells, …).
+ */
+export declare function useEditableDraft<TValue, TDraft = TValue>(params: {
+    value: TValue;
+    editing: boolean;
+    /** Project the source value into the draft shape. Omit for an identity draft. */
+    toDraft?: (value: TValue) => TDraft;
+}): UseEditableDraftResult<TDraft>;
+
+export declare interface UseEditableDraftResult<TDraft> {
+    /** The editable draft value. */
+    draft: TDraft;
+    /** Update the draft locally (e.g. on input change). */
+    setDraft: Dispatch<SetStateAction<TDraft>>;
+    /** Force the draft back to the current source value (e.g. on Escape / cancel). */
+    reset: () => void;
+}
+
+/**
+ * Optimistic mutation over a family of React Query list caches matched by a
+ * partial key. Same lifecycle as `useOptimisticResource` (cancel + snapshot +
+ * patch in `onMutate`, rollback in `onError`, reconcile-not-invalidate on
+ * success), but it patches every matching cache so filtered/paginated views of
+ * the same list stay consistent. Framework-generic: the caller's
+ * `applyOptimistic`/`reconcile` own all knowledge of the cache shape.
+ */
+export declare function useOptimisticList<TCache, TVariables, TResult = unknown>(params: UseOptimisticListParams<TCache, TVariables, TResult>): UseMutationResult<TResult, unknown, TVariables, OptimisticListContext<TCache>>;
+
+export declare interface UseOptimisticListParams<TCache, TVariables, TResult> {
+    /**
+     * Partial query key. EVERY cache whose key starts with this is patched
+     * (React Query's `getQueriesData` / `setQueriesData` semantics) — e.g. a
+     * paginated/filtered list keyed `['workstreams', week, search]` is patched
+     * across all its variants with one mutation.
+     */
+    queryKey: QueryKey;
+    /** The async write. Its resolved value is the `result` passed to reconcile. */
+    mutationFn: (variables: TVariables) => Promise<TResult>;
+    /**
+     * Patch one matching cache value, applied synchronously in `onMutate`.
+     * Called once per matching entry. Return the cache unchanged to skip it.
+     */
+    applyOptimistic: (args: {
+        cache: TCache;
+        variables: TVariables;
+    }) => TCache;
+    /**
+     * Reconcile each matching cache with the server result on success, WITHOUT a
+     * refetch. Omit to trust the optimistic patch — the no-flash-back default.
+     */
+    reconcile?: (args: {
+        cache: TCache;
+        result: TResult;
+        variables: TVariables;
+    }) => TCache;
+    /**
+     * Invalidate the PATCHED key on settle. Defaults to `false`: re-running the
+     * list query lets a stale in-flight response overwrite the patch for a frame
+     * (flash-back). Only enable when you cannot reconcile from the server result.
+     */
+    invalidateOnSettle?: boolean;
+    /**
+     * Sibling query keys to invalidate on success. Must NOT include `queryKey` —
+     * only caches you did not optimistically patch (e.g. an aggregate the list
+     * feeds). Refetching those is safe and keeps them fresh.
+     */
+    invalidateKeysOnSuccess?: QueryKey[];
+    onError?: (args: {
+        error: unknown;
+        variables: TVariables;
+    }) => void;
+    onSuccess?: (args: {
+        result: TResult;
+        variables: TVariables;
+    }) => void;
+    onSettled?: (args: {
+        variables: TVariables;
+    }) => void;
+}
+
+/**
+ * Optimistic mutation over a single React Query cache entry.
+ *
+ * Encapsulates the full lifecycle the Jarvis playbook prescribes:
+ * `onMutate` cancels in-flight queries, snapshots the entry, and applies an
+ * optimistic patch; `onError` rolls back to the snapshot; `onSuccess`
+ * reconciles from the server result (or trusts the patch); and settle does NOT
+ * blindly invalidate the patched key. Framework-generic — it knows nothing
+ * about the resource shape beyond what the caller's callbacks describe.
+ *
+ * For multiple matching caches each holding a list, use `useOptimisticList`.
+ */
+export declare function useOptimisticResource<TData, TVariables, TResult = unknown>(params: UseOptimisticResourceParams<TData, TVariables, TResult>): UseMutationResult<TResult, unknown, TVariables, OptimisticResourceContext<TData>>;
+
+export declare interface UseOptimisticResourceParams<TData, TVariables, TResult> {
+    /** Exact query key of the cache entry holding the resource. */
+    queryKey: QueryKey;
+    /** The async write. Its resolved value is the `result` passed to reconcile. */
+    mutationFn: (variables: TVariables) => Promise<TResult>;
+    /**
+     * Produce the optimistically-patched cache value, applied synchronously in
+     * `onMutate`. Receives the pre-mutation value (or `undefined` when the cache
+     * is empty). Return `previous` unchanged to skip the patch.
+     */
+    applyOptimistic: (args: {
+        previous: TData | undefined;
+        variables: TVariables;
+    }) => TData | undefined;
+    /**
+     * Reconcile the cache with the authoritative server result on success,
+     * WITHOUT a refetch. Omit to trust the optimistic patch — the no-flash-back
+     * default. Prefer this over `invalidateOnSettle` whenever the server result
+     * carries the canonical shape (it sets the cache directly, so there is no
+     * stale-poll window the way an invalidate-driven refetch has).
+     */
+    reconcile?: (args: {
+        previous: TData | undefined;
+        result: TResult;
+        variables: TVariables;
+    }) => TData | undefined;
+    /**
+     * Invalidate the PATCHED key on settle. Defaults to `false`: invalidating a
+     * key you just optimistically patched re-runs its query and lets a stale
+     * in-flight response overwrite the patch for a frame — the flash-back the
+     * Jarvis frontend-mutations playbook warns against. Only enable when you
+     * cannot reconcile from the server result.
+     */
+    invalidateOnSettle?: boolean;
+    /**
+     * Sibling query keys to invalidate on success. These must NOT include
+     * `queryKey` — only caches you did not optimistically patch (e.g. a list the
+     * detail view doesn't render). Refetching those is safe and keeps them fresh.
+     */
+    invalidateKeysOnSuccess?: QueryKey[];
+    onError?: (args: {
+        error: unknown;
+        variables: TVariables;
+        previous: TData | undefined;
+    }) => void;
+    onSuccess?: (args: {
+        result: TResult;
+        variables: TVariables;
+    }) => void;
+    onSettled?: (args: {
+        variables: TVariables;
+    }) => void;
+}
+
+/**
+ * A drop-in replacement for `Tabs`' uncontrolled `defaultValue` that survives a
+ * reload — built for Artifact Studio artifacts.
+ *
+ * Artifacts run inside an iframe the preview page re-keys (by deployment id) on
+ * every `seq-studio artifact dev` rebuild, so each rebuild fully *remounts* the
+ * iframe to a fresh `src`: a brand-new browsing context that wipes React state,
+ * the HashRouter route, and the active tab. We use `localStorage` (not
+ * `sessionStorage`) deliberately: a remounted iframe is a new browsing context,
+ * so sessionStorage survival across the remount is browser/spec-dependent, while
+ * localStorage is origin/partition-scoped and persists regardless. It also keeps
+ * the tab across a normal page refresh.
+ *
+ * Feed the returned tuple straight into a Radix `Tabs`:
+ *
+ * ```tsx
+ * const [tab, setTab] = usePersistentTabValue({
+ *   storageKey: 'my-artifact:detail-tab',
+ *   defaultValue: 'overview',
+ * })
+ * <Tabs value={tab} onValueChange={setTab}>…</Tabs>
+ * ```
+ *
+ * `storageKey` must be a stable, app-unique string. Compose in an entity id
+ * (e.g. `my-artifact:workstream:${id}:tab`) if each entity should remember its
+ * own tab.
+ */
+export declare function usePersistentTabValue({ storageKey, defaultValue, }: {
+    storageKey: string;
+    defaultValue: string;
+}): readonly [string, (value: string) => void];
+
+export declare function usePortalContainer(): HTMLElement | null;
+
+export declare function UserAvatar({ name, avatarUrl, colorKey, initials: explicitInitials, size, fallback, className, }: UserAvatarProps): JSX.Element;
+
+export declare interface UserAvatarProps {
+    name: string;
+    /** Profile image URL. Falls back to initials or the neutral icon. */
+    avatarUrl?: string | null;
+    /** Stable identifier for deterministic color (e.g. email). Falls back to name. */
+    colorKey?: string;
+    /**
+     * Optional explicit initials (e.g. "AR", "ML"). Use when the displayed
+     * `name` is a single token but you want a two-letter avatar — common in
+     * Jarvis where `emailToName()` returns just the first name from the
+     * TEAM roster. Falls back to deriving from `name` when omitted, which
+     * yields a single letter for one-word names.
+     */
+    initials?: string;
+    /** Size in px. Defaults to 20. */
+    size?: number;
+    /** Initials are the identity default; icon is for generic/unassigned people. */
+    fallback?: 'initials' | 'icon';
+    className?: string;
+}
+
+/**
+ * A person rendered as a first-class platform entity: an avatar (+ optional
+ * name) that reveals an identity card on hover — name, email, organization, and
+ * role. Read-only; use the same component everywhere a user appears so people
+ * feel like consistent, recognizable objects across the platform.
+ */
+export declare function UserChip({ user, showName, size, className }: UserChipProps): JSX.Element;
+
+export declare interface UserChipProps {
+    user: UserChipUser;
+    /** Render the name beside the avatar. When false, only the avatar shows. */
+    showName?: boolean;
+    /** Avatar size in px (the inline trigger). Defaults to 22. */
+    size?: number;
+    className?: string;
+}
+
+/**
+ * Canonical shape for a platform user, mirroring the fields the Users surface
+ * (chat-admin user management + `/api/user/list`) exposes. Only `name` is
+ * required; everything else degrades gracefully.
+ */
+export declare interface UserChipUser {
+    name: string;
+    email?: string | null;
+    /** Tenant / org the user belongs to (e.g. "Sequence", "Acme Corp"). */
+    organization?: string | null;
+    role?: string | null;
+    /** Profile image URL; falls back to a deterministic initials avatar. */
+    avatarUrl?: string | null;
+    /** Stable id for deterministic avatar color (defaults to email, then name). */
+    colorKey?: string;
+    /** Explicit initials override (e.g. "AR") when `name` is a single token. */
+    initials?: string;
+}
+
+/**
+ * Resolve a `ParsedDate` (year/month/day, any of which may be null)
+ * into a concrete `Date`, using the reference date and `dayDefault`
+ * to fill in the missing pieces.
+ *
+ * Decisions:
+ *   - Missing day: 1st of the month for `start`, last day for `end`.
+ *   - Missing month: January (start) or December (end).
+ *   - Missing year: current year, unless picking that year would put
+ *     the date in the future for "bare month" inputs — in which case
+ *     we fall back to the prior year (matches Mercury's behaviour for
+ *     "Dec" entered in July).
+ *
+ * Returns `null` if the resulting date doesn't actually exist (e.g.
+ * "Feb 30 2024" was typed).
+ */
+/**
+ * Direction the parser leans when a year is missing from the user's
+ * input. Default is `'past'` — matches the original retrospective bias
+ * (`"Dec"` in July → last December). Forward-planning surfaces (due
+ * dates, scheduling) pass `'future'` so `"Jun 8"` in May reads as the
+ * upcoming June 8 instead of last year's.
+ */
+declare type YearBias = 'past' | 'future';
+
+export { }
+
+
+declare module 'chart.js' {
+    interface TooltipPositionerMap {
+        cursor: TooltipPositionerFunction<ChartType>;
+    }
+}