@mt-gloss/ui 0.0.8 → 0.0.10

package/lib/primitives/dashboard/MetricCard/StatusModeCard.d.ts

@@ -0,0 +1,5 @@
+import { StatusModeVariant } from './types';
+export declare function StatusModeCard(props: StatusModeVariant): import("react/jsx-runtime").JSX.Element;
+export declare namespace StatusModeCard {
+    var displayName: string;
+}

package/lib/primitives/dashboard/MetricCard/StatusSlotChipMenu.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+/** A single overflow action entry (opaque — consumer fills these). */
+export interface ChipMenuAction {
+    id: string;
+    label: string;
+    onSelect: (statusId: string) => void;
+}
+/** Props for StatusSlotChipMenu. */
+export interface StatusSlotChipMenuProps {
+    /** Whether the menu is visible. */
+    open: boolean;
+    /** The slot element that was clicked — used as anchor for positioning. */
+    anchorEl: HTMLElement | null;
+    /** Status identifier for callback identity only — not treated as domain data. */
+    statusId: string;
+    /** Primary action: open the associated data table. */
+    onOpenInTable: (statusId: string) => void;
+    /** Standard action: show this status on the graph. Always present. */
+    onShowOnGraph: (statusId: string) => void;
+    /** Overflow actions (opaque — reptime-supplied, e.g. Angular deep-links). */
+    overflowActions?: ReadonlyArray<ChipMenuAction>;
+    /** Called when menu should close (Escape, outside click, or after action). */
+    onClose: () => void;
+}
+export declare function StatusSlotChipMenu({ open, anchorEl, statusId, onOpenInTable, onShowOnGraph, overflowActions, onClose, }: StatusSlotChipMenuProps): React.ReactPortal | null;
+export declare namespace StatusSlotChipMenu {
+    var displayName: string;
+}

package/lib/primitives/dashboard/MetricCard/flipAndStage/FlipAndStageProvider.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { FlipAndStageValue } from './types';
+export interface FlipAndStageProviderProps {
+    children: ReactNode;
+}
+/**
+ * Context provider for flip-and-stage config mode.
+ *
+ * Mount once at MetricCardGrid scope. All descendant cards that call
+ * useFlipAndStageContext() share the same state instance, enforcing the
+ * one-card-at-a-time invariant automatically.
+ */
+export declare function FlipAndStageProvider({ children }: FlipAndStageProviderProps): JSX.Element;
+/**
+ * Access the flip-and-stage context value.
+ *
+ * Must be called inside a <FlipAndStageProvider> — throws an invariant error otherwise.
+ *
+ * @throws {Error} When called outside a FlipAndStageProvider
+ */
+export declare function useFlipAndStageContext(): FlipAndStageValue;
+/**
+ * Optional variant of useFlipAndStageContext that returns null instead of throwing
+ * when called outside a FlipAndStageProvider.
+ *
+ * Used by MetricCardGrid for graceful degradation — the grid renders normally
+ * without config-mode panel when no provider is present.
+ */
+export declare function useFlipAndStageContextOptional(): FlipAndStageValue | null;

package/lib/primitives/dashboard/MetricCard/flipAndStage/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Phase 13, Plan 01: flipAndStage barrel export.
+ *
+ * Re-exports everything needed by consumers of the flip-and-stage feature:
+ * - useFlipAndStage hook
+ * - FlipAndStageProvider context provider
+ * - useFlipAndStageContext consumer hook
+ * - FLIP_AND_STAGE_TIMINGS animation contract
+ * - All public types
+ */
+export { useFlipAndStage } from './useFlipAndStage';
+export { FlipAndStageProvider, useFlipAndStageContext, useFlipAndStageContextOptional } from './FlipAndStageProvider';
+export type { FlipAndStageProviderProps } from './FlipAndStageProvider';
+export { FLIP_AND_STAGE_TIMINGS, } from './types';
+export type { FlipAndStageState, FlipAndStageValue, FlipAndStageInternalState, UseFlipAndStageOptions, } from './types';

package/lib/primitives/dashboard/MetricCard/flipAndStage/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Phase 13, Plan 01: useFlipAndStage type contracts.
+ *
+ * State machine: idle → configuring → idle
+ * One card at a time; switching cards silently discards prior dirty state (D-06).
+ * No framer-motion dependency — purely JS state.
+ *
+ * @module flipAndStage/types
+ */
+/**
+ * Animation timing contract for the flip-and-stage choreography.
+ *
+ * Phase: flip-start → panel-extrude → settle
+ * Total: 350ms
+ *
+ * @see D-05 (Phase 13 context)
+ */
+export declare const FLIP_AND_STAGE_TIMINGS: {
+    /** Delay before flip animation begins (ms). */
+    readonly flipStart: 50;
+    /** Duration of panel extrude animation (ms). */
+    readonly extrude: 200;
+    /** Duration of settle animation (ms). */
+    readonly settle: 100;
+    /** Total choreography duration (ms). */
+    readonly total: 350;
+};
+/** The two machine states for flip-and-stage config mode. */
+export type FlipAndStageState = 'idle' | 'configuring';
+/**
+ * Internal state managed by the useReducer inside useFlipAndStage.
+ * Not exposed directly — consumers use FlipAndStageValue.
+ */
+export interface FlipAndStageInternalState {
+    state: FlipAndStageState;
+    activeCardId: string | null;
+    activeDimensionId: string | null;
+    dirtyState: Record<string, unknown>;
+}
+/**
+ * The full value exposed by useFlipAndStage and FlipAndStageContext.
+ *
+ * - `activeCardId` — which card is in config mode (null = none)
+ * - `activeDimensionId` — optional dimension chosen from CardBack chooser
+ * - `state` — machine state ('idle' | 'configuring')
+ * - `dirtyState` — accumulated unsaved field edits
+ * - `beginConfig` — enter config mode for a card; silently replaces prior active card
+ * - `commitConfig` — persist edits and return to idle; optional patch merged into dirty
+ * - `cancelConfig` — discard edits and return to idle
+ * - `setDirty` — merge additional edits into dirtyState
+ */
+export interface FlipAndStageValue {
+    activeCardId: string | null;
+    activeDimensionId: string | null;
+    state: FlipAndStageState;
+    dirtyState: Record<string, unknown>;
+    /**
+     * Enter config mode for the given card.
+     * @param cardId - must be a non-empty string; null/empty is rejected with console.warn
+     * @param dimensionId - optional dimension for CardBack chooser
+     */
+    beginConfig: (cardId: string, dimensionId?: string) => void;
+    /**
+     * Commit edits and return to idle.
+     * No-op when state is 'idle'.
+     * @param patch - optional extra fields merged into dirtyState before onCommit fires
+     */
+    commitConfig: (patch?: Record<string, unknown>) => void;
+    /** Discard edits and return to idle. No-op when state is 'idle'. */
+    cancelConfig: () => void;
+    /** Merge additional dirty fields. Successive calls accumulate (not replace). */
+    setDirty: (patch: Record<string, unknown>) => void;
+}
+/**
+ * Options for useFlipAndStage.
+ */
+export interface UseFlipAndStageOptions {
+    /**
+     * Called when commitConfig fires.
+     * Receives the merged dirty state (existing + commit patch).
+     */
+    onCommit?: (merged: Record<string, unknown>) => void;
+}

package/lib/primitives/dashboard/MetricCard/flipAndStage/useFlipAndStage.d.ts

@@ -0,0 +1,10 @@
+import { FlipAndStageValue, UseFlipAndStageOptions } from './types';
+/**
+ * State machine hook for the flip-and-stage config mode choreography.
+ *
+ * Provides begin/commit/cancel/setDirty actions with stable useCallback references.
+ * Suitable for use as the inner implementation behind FlipAndStageProvider.
+ *
+ * @param options.onCommit - fired when commitConfig() is called; receives merged dirty state
+ */
+export declare function useFlipAndStage(options?: UseFlipAndStageOptions): FlipAndStageValue;

package/lib/primitives/dashboard/MetricCard/index.d.ts

@@ -4,12 +4,22 @@ export { CardBack } from './CardBack';
 export { TrendIndicator } from './TrendIndicator';
 export { GutterActions } from './GutterActions';
 export { StackedGroupCard } from './StackedGroupCard';
+export { StatusModeCard } from './StatusModeCard';
+export { StatusSlotChipMenu } from './StatusSlotChipMenu';
+export type { StatusSlotChipMenuProps, ChipMenuAction } from './StatusSlotChipMenu';
+export { EdgeHoverHandle } from './EdgeHoverHandle';
+export { GhostPreview } from './GhostPreview';
 export { useSlideOutReveal } from './useSlideOutReveal';
+export { useEdgeHoverResize } from './useEdgeHoverResize';
+export * from './flipAndStage';
 export * from './types';
 export type { CardBackProps } from './CardBack';
 export type { GutterActionsProps } from './GutterActions';
 export type { StackedGroupCardProps, StackedValueEntry } from './StackedGroupCard';
 export type { SlideOutRevealConfig, SlideOutRevealReturn } from './useSlideOutReveal';
+export type { ResizeState, ResizeDirection, ResizeMode, ResizeCommit, UseEdgeHoverResizeArgs, UseEdgeHoverResizeReturn, } from './useEdgeHoverResize';
+export type { EdgeHoverHandleProps } from './EdgeHoverHandle';
+export type { GhostPreviewProps } from './GhostPreview';
 export { SparklineBg } from './visualizations/SparklineBg';
 export { BarsBg } from './visualizations/BarsBg';
 export { DonutChart } from './visualizations/DonutChart';

package/lib/primitives/dashboard/MetricCard/types.d.ts

@@ -24,6 +24,10 @@ export interface VersusData {
     currentLabel?: string;
     priorLabel?: string;
 }
+/** Card display mode — default 'time-period' is back-compat with all existing variants. */
+export type MetricCardMode = 'time-period' | 'status';
+/** Slot capacity for Status Mode width-driven rendering (Plan 02). */
+export type SlotCapacity = 1 | 3 | 5;
 /** Base props shared by all MetricCard variants. */
 export interface BaseMetricCardProps {
     label: string;
@@ -31,11 +35,20 @@ export interface BaseMetricCardProps {
     valueFormat?: ValueFormat;
     trend?: TrendData | null;
     subtitle?: string;
-    colSpan?: 1 | 2;
+    colSpan?: 1 | 2 | 3;
     isStale?: boolean;
     isLoading?: boolean;
     isError?: boolean;
     isEmpty?: boolean;
+    /** Display mode — undefined is equivalent to 'time-period' for back-compat. */
+    mode?: MetricCardMode;
+    /**
+     * Phase 15 — threshold visual breach treatment (D-06).
+     * 'warn'     → amber border tint + WarningIcon (NEVER color-only, D-28)
+     * 'critical' → red border tint + CriticalIcon + pulse animation
+     * 'none'     → no treatment (default)
+     */
+    thresholdBreach?: 'none' | 'warn' | 'critical';
 }
 export interface StandardVariant extends BaseMetricCardProps {
     variant: 'standard';
@@ -78,8 +91,31 @@ export interface SegmentedVariant extends BaseMetricCardProps {
     variant: 'segmented';
     segments: SegmentEntry[];
 }
+/** A single status slot entry for Status Mode cards (Phase 10). */
+export interface StatusEntry {
+    id: string;
+    label: string;
+    value: number | string;
+    accentColor?: string;
+}
+/** Status Mode variant — flag-gated; renders status slots instead of time-period value. */
+export interface StatusModeVariant extends BaseMetricCardProps {
+    variant: 'status-mode';
+    statuses: ReadonlyArray<StatusEntry>;
+    activeStatusId?: string;
+    /** Per-status sparkline data keyed by status.id (Plan 02). */
+    sparklinePerStatus?: Record<string, ReadonlyArray<number>>;
+    /** Override computed slot capacity — test hook / opt-out (Plan 02). */
+    maxSlots?: SlotCapacity;
+    /**
+     * Called when a status slot is clicked (Plan 04 — chip-menu wiring).
+     * statusId: the clicked slot's status id.
+     * anchorEl: the slot DOM element — used to anchor the chip menu.
+     */
+    onStatusSlotClick?: (statusId: string, anchorEl: HTMLElement) => void;
+}
 /** Discriminated union of all MetricCard variant props. */
-export type MetricCardProps = StandardVariant | SparklineVariant | BarsVariant | DonutVariant | HighlightVariant | ArrowVariant | ObjectArrowVariant | VersusVariant | SegmentedVariant;
+export type MetricCardProps = StandardVariant | SparklineVariant | BarsVariant | DonutVariant | HighlightVariant | ArrowVariant | ObjectArrowVariant | VersusVariant | SegmentedVariant | StatusModeVariant;
 /**
  * All card type identifiers for type-guard compatibility.
  * The 9 renderable variants (standard through segmented) map to MetricCardProps discriminated union.
@@ -90,13 +126,21 @@ export type MetricCardProps = StandardVariant | SparklineVariant | BarsVariant |
 export type MetricCardType = 'standard' | 'sparkline' | 'bars' | 'donut' | 'highlight' | 'arrow' | 'object-arrow' | 'versus' | 'segmented' | 'name' | 'ratio' | 'action' | 'stacked-group';
 /** Props for the CardShell wrapper component. */
 export interface CardShellProps {
-    children: ReactNode;
-    colSpan?: 1 | 2;
+    /** Preferred slot for card content. Use this instead of children. */
+    contentSlot?: ReactNode;
+    /** @deprecated Use contentSlot instead. */
+    children?: ReactNode;
+    colSpan?: 1 | 2 | 3;
     isStale?: boolean;
     isRetrying?: boolean;
     beta?: boolean;
     disabled?: boolean;
     style?: CSSProperties;
+    /**
+     * When true, renders a 2px accent ring around the card shell using box-shadow
+     * (NOT border, to avoid reflow). Used to indicate config mode is active (D-09).
+     */
+    accentRing?: boolean;
     onGraph?: () => void;
     onDetails?: () => void;
     onCustomize?: ((ref: RefObject<HTMLDivElement | null>) => void) | (() => void);

package/lib/primitives/dashboard/MetricCard/useEdgeHoverResize.d.ts

@@ -0,0 +1,52 @@
+export type ResizeState = 'idle' | 'dwelling' | 'handle-visible' | 'dragging' | 'committed' | 'cancelled';
+export type ResizeDirection = 'grow' | 'shrink';
+export type ResizeMode = 'slot-fill' | 'sparkline-fidelity';
+export interface ResizeCommit {
+    direction: ResizeDirection;
+    targetColSpan: 1 | 2 | 3;
+    mode: ResizeMode;
+}
+export interface UseEdgeHoverResizeArgs {
+    currentColSpan: 1 | 2 | 3;
+    stackable: boolean;
+    onResize: (commit: ResizeCommit) => void;
+    onCancel?: () => void;
+    /** Hover dwell time before handle appears. Default: 120ms */
+    dwellMs?: number;
+    /** AN-06 enter motion duration exposed for consumer CSS. Default: 180ms */
+    enterMs?: number;
+    /** AN-06 exit motion duration exposed for consumer CSS. Default: 120ms */
+    exitMs?: number;
+}
+export interface UseEdgeHoverResizeReturn {
+    state: ResizeState;
+    enterEdgeZone: () => void;
+    leaveEdgeZone: () => void;
+    handleProps: {
+        onPointerDown: (e: React.PointerEvent) => void;
+        onPointerUp: (e: React.PointerEvent) => void;
+    };
+    ghostProps: {
+        visible: boolean;
+        enterMs: number;
+        exitMs: number;
+    };
+}
+/**
+ * useEdgeHoverResize — State machine for edge-hover-to-resize gesture.
+ *
+ * State flow:
+ *   idle → dwelling (hover dwell 120ms) → handle-visible → dragging (pointerdown) → committed (pointerup) | cancelled
+ *   dwelling | handle-visible → idle (pointer leaves edge zone)
+ *   dragging | handle-visible → cancelled (Escape key)
+ *
+ * The hook does NOT inspect any reptime-domain data. The consumer passes `stackable`
+ * (from metricInfo) and the hook emits the correct mode string — no cross-domain leakage.
+ *
+ * Threat mitigations:
+ *   T-10.03-01: clearDwell() in cleanup useEffect prevents timer leak on unmount
+ *   T-10.03-02: Math.min/max clamp keeps targetColSpan ∈ {1,2,3}
+ *
+ * Motion contract (AN-06): enterMs=180, exitMs=120 (defaults)
+ */
+export declare function useEdgeHoverResize({ currentColSpan, stackable, onResize, onCancel, dwellMs, enterMs, exitMs, }: UseEdgeHoverResizeArgs): UseEdgeHoverResizeReturn;

package/lib/primitives/dashboard/MetricCard/useSlotCapacity.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+export type SlotCapacity = 1 | 3 | 5;
+export declare function useSlotCapacity(ref: RefObject<HTMLElement | null>, opts?: {
+    thresholds?: {
+        slot3: number;
+        slot5: number;
+    };
+    debounceMs?: number;
+}): {
+    capacity: SlotCapacity;
+    onPointerUp: () => void;
+};

package/lib/primitives/dashboard/MetricCardGrid/MetricCardGrid.d.ts

@@ -1,28 +1,30 @@
 import { default as React } from 'react';
 import { MetricCardGridProps } from './types';
 /**
- * MetricCardGrid - CSS grid layout with @dnd-kit drag-and-drop reordering.
+ * Finds the best adjacent slot to extrude the QuickConfigPanel into.
  *
- * Renders cards in a paginated grid with sortable slots. Card rendering is fully
- * delegated to the `renderCard` render prop. Empty slots can be customized via
- * `renderEmptySlot`. The grid manages DnD interaction internally and reports
- * order changes via `onReorder`.
+ * Priority: right → below → left → above.
+ * Returns null if activeIndex is invalid or no candidates exist.
  *
- * @example
- * ```tsx
- * import { MetricCardGrid } from '@mt-gloss/ui';
- * import type { GridCardData, GridLayout } from '@mt-gloss/ui';
+ * When all neighbors are occupied (packed grid), returns the right neighbor
+ * index for dim-cover fallback — the caller distinguishes empty vs occupied
+ * by checking if extrudeIndex >= cardCount.
  *
- * const layout: GridLayout = { columns: 6, rowHeight: 120, gap: 15, maxRows: 3, currentPage: 0, totalPages: 1 };
+ * @param activeIndex  Index of the active card in the ordered visible-cards array (0-based)
+ * @param cardCount    Total number of cards in the visible page
+ * @param columns      Grid column count
+ */
+export declare function findExtrudeSlot(activeIndex: number, cardCount: number, columns: number): number | null;
+/**
+ * MetricCardGrid - CSS grid layout with @dnd-kit drag-and-drop reordering.
  *
- * <MetricCardGrid
- *   cards={cards}
- *   cardOrder={cardOrder}
- *   layout={layout}
- *   onReorder={setCardOrder}
- *   onPageChange={setPage}
- *   renderCard={(card) => <MyCard data={card} />}
- * />
- * ```
+ * Config-mode extension (Phase 13, D-07):
+ * - Reads activeCardId from FlipAndStageProvider via useFlipAndStageContextOptional
+ * - When activeCardId is set, places QuickConfigPanel adjacent to active card
+ * - Extrude-first: empty neighbor gets panel (right→below→left→above priority)
+ * - Packed grid: dims right neighbor (opacity:0.3, pointer-events:none, aria-hidden)
+ * - Source card stays full opacity, never aria-hidden (D-08)
+ * - AnimatePresence wraps panel: transform+opacity only (AN-01)
+ * - Graceful degradation: no FlipAndStageProvider → null context → no panel, no crash
  */
 export declare const MetricCardGrid: React.NamedExoticComponent<MetricCardGridProps>;

package/lib/primitives/dashboard/MetricCardGrid/types.d.ts

@@ -1,8 +1,9 @@
 import { ReactNode } from 'react';
+import { QuickConfigSection } from '../../../composites/dashboard/QuickConfigPanel/types';
 /** Data for a single card slot in the grid. */
 export interface GridCardData {
     id: string;
-    colSpan: 1 | 2;
+    colSpan: 1 | 2 | 3;
     content: ReactNode;
 }
 /** Grid layout configuration. */
@@ -25,4 +26,10 @@ export interface MetricCardGridProps {
     onShrink?: (cardId: string) => void;
     renderCard: (card: GridCardData) => ReactNode;
     renderEmptySlot?: (index: number) => ReactNode;
+    /**
+     * Sections passed through to QuickConfigPanel when config mode is active.
+     * Required for panel to render meaningful content during flip-and-stage.
+     * D-07: panel renders adjacent to active card slot.
+     */
+    configSections?: QuickConfigSection[];
 }

package/lib/primitives/dashboard/MetricGroupContainer/MetricGroupContainer.d.ts

@@ -0,0 +1,5 @@
+import { MetricGroupContainerProps } from './types';
+export declare const MetricGroupContainer: {
+    (props: MetricGroupContainerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/primitives/dashboard/MetricGroupContainer/__tests__/fixtures.d.ts

@@ -0,0 +1,13 @@
+import { MetricGroupContainerProps } from '../types';
+export declare const DISCRETE_2: Extract<MetricGroupContainerProps, {
+    renderMode: 'discrete';
+}>;
+export declare const DISCRETE_4: Extract<MetricGroupContainerProps, {
+    renderMode: 'discrete';
+}>;
+export declare const COMPOSITE_2_NO_CHROME: Extract<MetricGroupContainerProps, {
+    renderMode: 'composite';
+}>;
+export declare const COMPOSITE_2_WITH_CHROME: Extract<MetricGroupContainerProps, {
+    renderMode: 'composite';
+}>;

package/lib/primitives/dashboard/MetricGroupContainer/index.d.ts

@@ -0,0 +1,2 @@
+export { MetricGroupContainer } from './MetricGroupContainer';
+export * from './types';

package/lib/primitives/dashboard/MetricGroupContainer/types.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+/**
+ * Opaque slot data consumed by {@link MetricGroupContainer}.
+ * The container never introspects `children` — the consumer (e.g. reptime MetricGroupHost)
+ * materializes any React content it wants into each slot.
+ *
+ * VO-01-A: this file's exported fields are the strict subset
+ * {renderMode, cards, composite} — no metricId, groupId, dataSource, cardType, or
+ * reptime entity-type strings. Enforced by Plan 03 ESLint rule + vitest source-grep.
+ */
+export interface GroupSlot {
+    key: string;
+    gridPosition: {
+        col: number;
+        row: number;
+    };
+    size: 'standard' | 'wide' | 'tall';
+    children: ReactNode;
+}
+export type MetricGroupContainerProps = {
+    renderMode: 'discrete';
+    cards: GroupSlot[];
+} | {
+    renderMode: 'composite';
+    cards: GroupSlot[];
+    composite?: {
+        label?: string;
+        accentColor?: string;
+        trend?: {
+            direction: 'up' | 'down' | 'flat';
+            delta?: string;
+        };
+    };
+};

package/lib/primitives/dashboard/PageChip/PageChip.d.ts

@@ -0,0 +1,27 @@
+import { PageChipProps } from './types';
+/**
+ * PageChip -- Corner-mounted page navigation chip.
+ *
+ * Renders with `position: absolute` at top-right of its container (AP-06
+ * compliant: zero grid-cell occupancy). Displays a "{current} / {total}"
+ * label and opens a PageDropdown on click.
+ *
+ * The nuzzle mask creates a concave cutout via `mask-image: radial-gradient`,
+ * matching the production-proven technique from FusedShape.tsx.
+ *
+ * @example
+ * ```tsx
+ * <PageChip
+ *   currentIndex={0}
+ *   total={3}
+ *   pages={pages}
+ *   onPageChange={handleSwitch}
+ *   onCreatePage={handleCreate}
+ *   onManagePages={handleManage}
+ * />
+ * ```
+ */
+export declare const PageChip: {
+    ({ currentIndex, total, pages, onPageChange, onCreatePage, onManagePages, maskRadius, }: PageChipProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/primitives/dashboard/PageChip/PageDropdown.d.ts

@@ -0,0 +1,29 @@
+import { PageDropdownProps } from './types';
+/**
+ * PageDropdown -- Page navigation dropdown composed on BasePopover.
+ *
+ * Renders exactly one `[role=menu]` element (AP-04 compliant: no nested
+ * overlays or sub-views). Lists pages with filled/hollow dot indicators,
+ * muted metric count, and italic styling for unnamed pages.
+ *
+ * Contains two action rows: "+ New page" and "Manage pages", separated
+ * by horizontal rules.
+ *
+ * @example
+ * ```tsx
+ * <PageDropdown
+ *   open={isOpen}
+ *   onDismiss={close}
+ *   anchorRef={chipRef}
+ *   pages={pages}
+ *   activePageId="p1"
+ *   onPageChange={handleSwitch}
+ *   onCreatePage={handleCreate}
+ *   onManagePages={handleManage}
+ * />
+ * ```
+ */
+export declare function PageDropdown({ open, onDismiss, anchorRef, pages, activePageId, onPageChange, onCreatePage, onManagePages, }: PageDropdownProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PageDropdown {
+    var displayName: string;
+}

package/lib/primitives/dashboard/PageChip/index.d.ts

@@ -0,0 +1,3 @@
+export { PageChip } from './PageChip';
+export { PageDropdown } from './PageDropdown';
+export * from './types';

package/lib/primitives/dashboard/PageChip/types.d.ts

@@ -0,0 +1,36 @@
+import { RefObject } from 'react';
+/** Describes a single page entry in the dropdown list. */
+export interface PageInfo {
+    id: string;
+    name: string;
+    named: boolean;
+    cardCount: number;
+}
+/** Props for the PageChip corner navigation element. */
+export interface PageChipProps {
+    /** 0-based index of the active page. */
+    currentIndex: number;
+    /** Total page count. */
+    total: number;
+    /** Array of page info objects for the dropdown. */
+    pages: PageInfo[];
+    /** Callback when user selects a different page. */
+    onPageChange: (pageId: string) => void;
+    /** Callback when user clicks "+ New page". */
+    onCreatePage: () => void;
+    /** Callback when user clicks "Manage pages". */
+    onManagePages: () => void;
+    /** CSS value for nuzzle mask radius; defaults to 'var(--gloss-radius-md)'. */
+    maskRadius?: string;
+}
+/** Props for the PageDropdown popover. */
+export interface PageDropdownProps {
+    open: boolean;
+    onDismiss: () => void;
+    anchorRef: RefObject<HTMLElement | null>;
+    pages: PageInfo[];
+    activePageId: string;
+    onPageChange: (pageId: string) => void;
+    onCreatePage: () => void;
+    onManagePages: () => void;
+}

package/lib/primitives/dashboard/TimeFrame/SimpleSelector.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { DateRangeValue } from './types';
+export interface SimpleSelectorProps {
+    value: DateRangeValue;
+    onChange: (value: DateRangeValue) => void;
+    onPresetChange?: (presetId: string) => void;
+    activePresetId?: string | null;
+}
+export declare const SimpleSelector: React.FC<SimpleSelectorProps>;

package/lib/primitives/dashboard/TimeFrame/index.d.ts

@@ -8,6 +8,8 @@ export { TimeFrame } from './TimeFrame';
 export { MiniCalendar } from './MiniCalendar';
 export { ExpandableChip } from './ExpandableChip';
 export { MarketPresetRow } from './MarketPresetRow';
+export { SimpleSelector } from './SimpleSelector';
+export type { SimpleSelectorProps } from './SimpleSelector';
 export type { HybridDatePickerProps, TimeFrameProps, MiniCalendarProps, ExpandableChipProps, MarketPresetRowProps, MarketPresetData, DateRangeValue, CompareValue, DateChangePayload, DatePreferences, ComparePreferences, MarketEvent, PresetDefinition, MarketPreset, DateRange, CalendarSize, RangeColor, MarketDateInfo, } from './types';
 export { formatDateRange, formatMarketDates, isMarketActive, isSameDay, isInRange, generateMarketId } from './utils/dateHelpers';
 export { getDateRangeForPreset, findPreset, getPresetLabel, normalizePresetId, toUppercasePresetId, getAllPresets, ROLLING_OPTIONS, PERIOD_OPTIONS, TODAY_PRESET, DEFAULT_MARKET_PRESETS, DEFAULT_PINNED, } from './utils/presets';

package/lib/primitives/dashboard/TimeFrame/types.d.ts

@@ -199,4 +199,12 @@ export interface TimeFrameProps {
     onMarketDelete?: (marketId: string) => void;
     /** MUI sx prop for container styling */
     sx?: SxProps<Theme>;
+    /**
+     * Render variant.
+     * 'full' = existing HybridDatePicker with calendar (default).
+     * 'simple-selector' = compact sectioned dropdown of preset shortcuts for reconfig panel.
+     */
+    variant?: 'full' | 'simple-selector';
+    /** Currently active preset ID — used by simple-selector to highlight active option */
+    activePresetId?: string | null;
 }

package/lib/primitives/dashboard/UnifiedContextMenu/types.d.ts

@@ -61,6 +61,8 @@ export interface UnifiedMenuAction {
     subtitle?: string;
     /** Dynamic label function based on row and entity context */
     labelFn?: (row: Record<string, unknown>, entityType?: string) => string;
+    /** Visual variant (e.g., 'destructive' for delete actions) */
+    variant?: 'default' | 'destructive';
 }
 /**
  * Context provided to menu action handlers.

package/lib/primitives/dashboard/index.d.ts

@@ -2,9 +2,11 @@ export * from './FilterChip';
 export * from './TabGroup';
 export * from './Skeleton';
 export * from './MetricCard';
+export * from './PageChip';
 export * from './UnifiedBreakdownTable';
 export * from './ChartControlBar';
 export * from './UnifiedContextMenu';
 export * from './TimeFrame';
 export * from './MetricCardGrid';
 export * from './TabbedDataView';
+export * from './MetricGroupContainer';