@mt-gloss/ui 0.1.73 → 0.1.75

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

@@ -6,22 +6,20 @@ 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 { useEdgeHoverResize } from './useEdgeHoverResize';
 export { DEFAULT_RESIZE_PHYSICS } from './resizePhysics';
 export type { ResizePhysicsConfig } from './resizePhysics';
 export { VelocityBuffer } from './velocityBuffer';
 export type { VelocitySample } from './velocityBuffer';
 export { DEFAULT_GRID_INTERACTION_PHYSICS } from './gridInteractionPhysics';
 export type { GridInteractionPhysicsConfig } from './gridInteractionPhysics';
+export * from '../ResizePill';
 export * from './flipAndStage';
 export * from './types';
 export type { CardBackProps } from './CardBack';
 export type { StackedGroupCardProps, StackedValueEntry, SlotActionStripConfig, SlotToActionStripConfig, } from './StackedGroupCard';
-export type { ResizeState, ResizeDirection, ResizeMode, ResizeCommit, UseEdgeHoverResizeArgs, UseEdgeHoverResizeReturn, } from './useEdgeHoverResize';
+export type { ResizeCommit, ResizeDirection, ResizeMode } from './resizeTypes';
 export type { ChoreographyPhase, UseResizeChoreographyReturn } from './useResizeChoreography';
-export type { EdgeHoverHandleProps } from './EdgeHoverHandle';
 export type { GhostPreviewProps } from './GhostPreview';
 export { SparklineBg } from './visualizations/SparklineBg';
 export { BarsBg } from './visualizations/BarsBg';

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

@@ -0,0 +1,23 @@
+/**
+ * resizeTypes — Phase 11.3 cycle-4 Plan 01 Task 5.
+ *
+ * Lifted from useEdgeHoverResize.ts ahead of that file's deletion (Task 6,
+ * PILL-09). Plans 03/04/05 depend on the ResizeCommit / ResizeDirection /
+ * ResizeMode contract — useResizePillCommit (Plan 03) constructs the SAME
+ * ResizeCommit shape the predecessor's drag-handle gesture used so it can be
+ * routed through the existing E3 RESIZE_COMMIT path in useResizeHandlers
+ * without any consumer-side changes.
+ *
+ * Type-only file (no behavior). useEdgeHoverResize.ts re-imports from here
+ * during the Task 5 → Task 6 deletion window so the build stays green between
+ * the extraction commit and the deletion commit.
+ *
+ * Authority: .planning/phases/11.3-resize-pill/11.3-REMOVAL-MODE-ADDENDUM.md §3.
+ */
+export type ResizeDirection = 'grow' | 'shrink';
+export type ResizeMode = 'slot-fill' | 'sparkline-fidelity';
+export interface ResizeCommit {
+    direction: ResizeDirection;
+    targetColSpan: 1 | 2 | 3;
+    mode: ResizeMode;
+}

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

@@ -1,29 +1,37 @@
-import { UseEdgeHoverResizeReturn } from './useEdgeHoverResize';
 import { CellTintVariant } from '../CellTintOverlay';
+/**
+ * Structural shape of the resize-gesture output the choreography hook
+ * subscribes to. Lifted from the retired useEdgeHoverResize.ts (Phase 11.3
+ * Plan 01 Task 6 / PILL-09) so the choreography hook keeps its input-agnostic
+ * contract. Plan 03's `useResizePillCommit` constructs the same shape from
+ * the click-based resize pill.
+ */
+interface ResizeGestureOutput {
+    /** Lifecycle state string — choreography reads {idle, settling, cancelled}
+     *  as null-output; {arming, dwelling, handle-visible, dragging, active}
+     *  as channel-emitting. Pill adapter maps {trigger-hover, pill-visible,
+     *  pre-commit, fading} → equivalent legacy strings. */
+    state: string;
+    /** Direction discriminator. */
+    direction: string;
+    /** Card's current colSpan (pre-resize baseline). */
+    currentColSpan: 1 | 2 | 3;
+    /** Live preview colSpan as a float OR integer. Required for ramp lerp;
+     *  numbers between integers drive the ramp toward commit. */
+    previewColSpan: number;
+    /** Hysteresis-snapped target colSpan (D-07). Drives outline / tints / shrink. */
+    hysteresisTargetColSpan: 1 | 2 | 3;
+}
 type Cell = {
     section: 0 | 1 | 2 | 3;
     col: 0 | 1 | 2;
     row: 0 | 1 | 2;
 };
 export interface UseResizeChoreographyArgs {
-    /** Pass-through of useEdgeHoverResize return — never mutated. D-03. */
-    edgeHover: UseEdgeHoverResizeReturn & {
-        /** D-04 — locked lifecycle states. The base hook today exposes the legacy
-         *  ResizeState union; consumer-side adapters can also pass the canonical
-         *  4-state lifecycle. The hook treats {idle, settling, cancelled} as
-         *  null-output and {arming, dwelling, handle-visible, dragging, active}
-         *  as channel-emitting states. */
-        state: string;
-        /** Live preview colSpan as a float OR integer. Required for ramp lerp;
-         *  numbers between integers drive the ramp toward commit. */
-        previewColSpan: number;
-        /** Hysteresis-snapped target colSpan (D-07). Drives outline / tints / shrink. */
-        hysteresisTargetColSpan: 1 | 2 | 3;
-        /** Card's current colSpan (pre-resize baseline). */
-        currentColSpan: 1 | 2 | 3;
-        /** Direction discriminator. */
-        direction: string;
-    };
+    /** Pass-through resize-gesture output bag — never mutated. D-03.
+     *  Structural shape lifted from retired useEdgeHoverResize (PILL-09);
+     *  Plan 03's useResizePillCommit produces the same bag. */
+    edgeHover: ResizeGestureOutput;
     sourceCell: Cell;
     activeSection: 0 | 1 | 2 | 3;
     /** Cascade result for current preview colSpan — passed in from reptime reducer

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

@@ -0,0 +1,82 @@
+import { ResizePillPhysicsConfig } from './resizePillPhysics';
+import { PillButton, PillPhase, PillTarget } from './useResizePill';
+export type { PillButton, PillPhase, PillTarget };
+export interface ResizePillProps {
+    mode: 'directional' | 'sized';
+    currentTarget: PillTarget;
+    availableTargets: PillTarget[];
+    onCommit: (target: PillTarget) => void;
+    anchorLeftPx: number;
+    anchorTopPx: number | string;
+    hostWidth: number;
+    resolveTargetWidth: (target: PillTarget) => number;
+    /** Default false; Plan 04 (chart) sets true (D-10). */
+    showSizeTooltip?: boolean;
+    /** Default 'vertical'; Plan 04 sets 'horizontal' (D-11). */
+    orientation?: 'vertical' | 'horizontal';
+    onPhaseChange?: (phase: PillPhase) => void;
+    /** Mutex / global affordance gate. */
+    forceIdle?: boolean;
+    /** Gloss-side enable flag (Option B per PATTERNS §7). */
+    resizePillEnabled?: boolean;
+    phase: PillPhase;
+    pillVisible: boolean;
+    buttonHover: PillButton | null;
+    /** Trigger-zone + pill hover handlers from useResizePill.handlers. */
+    onTriggerEnter?: () => void;
+    onTriggerLeave?: () => void;
+    onPillEnter?: () => void;
+    onPillLeave?: () => void;
+    onButtonEnter?: (target: PillTarget) => void;
+    onButtonLeave?: () => void;
+    /** Optional override of physics tokens (test/dev tuning). */
+    physics?: Partial<ResizePillPhysicsConfig>;
+    /**
+     * Resolved preview target for the hovered button. Host computes from
+     * useResizePill.previewTarget. When null OR equal to currentTarget, the
+     * preview overlays do not render.
+     */
+    previewTarget?: PillTarget | null;
+    /**
+     * Direction of the resize for the chain stagger order. Host derives from
+     * (previewTarget vs currentTarget) — 'grow' when previewTarget > currentTarget,
+     * 'shrink' otherwise. Optional; defaults to 'grow'.
+     */
+    chainDirection?: 'grow' | 'shrink';
+    /**
+     * Pill edge px (chain start anchor). Host computes from anchorLeftPx +
+     * pill width. Optional; chain falls back to 0 when omitted (in which
+     * case the chain still renders but anchored at host origin).
+     */
+    chainStartX?: number;
+    /**
+     * Ghost edge px (chain end anchor). Host computes from anchorLeftPx +
+     * targetWidth. Optional; chain falls back to hostWidth when omitted.
+     */
+    chainEndX?: number;
+}
+/**
+ * Plan 02 contract — preview overlay (ghost + arrow chain + dot-matrix
+ * tooltip). Locked here so Plan 02 inputs are guaranteed to compose with
+ * Plan 01 outputs.
+ */
+export interface ResizePillPreviewProps {
+    buttonHover: PillButton | null;
+    previewTarget: PillTarget | null;
+    hostWidth: number;
+    /** resolveTargetWidth(previewTarget); host computes once per render. */
+    targetWidth: number;
+    pillClearancePx: number;
+    ghostClearancePx: number;
+    showSizeTooltip: boolean;
+}
+/**
+ * ResizePill — controlled primitive shell.
+ *
+ * Per ADR-grid-hook-comms §3.2: this primitive owns NO useState for
+ * `phase` / `pillSpan` / `pillVisible`. They come from props (host runs
+ * useResizePill). Internal useState is permitted ONLY for trigger-zone hover
+ * and pill-button-hover (which Plan 02's preview overlay also reads from
+ * useResizePill). Negative grep test (style-audit) enforces this.
+ */
+export declare const ResizePill: import('react').ForwardRefExoticComponent<ResizePillProps & import('react').RefAttributes<HTMLDivElement>>;

package/lib/primitives/dashboard/ResizePill/ResizePillArrowChain.d.ts

@@ -0,0 +1,22 @@
+export interface ResizePillArrowChainProps {
+    visible: boolean;
+    /** Chevron direction + stagger order. */
+    direction: 'grow' | 'shrink';
+    /** From DEFAULT_RESIZE_PILL_PHYSICS.pillClearancePx. */
+    pillClearancePx: number;
+    /** From DEFAULT_RESIZE_PILL_PHYSICS.ghostClearancePx. */
+    ghostClearancePx: number;
+    /** Pill edge px (host-computed; chain anchors here + pillClearancePx). */
+    startX: number;
+    /** Ghost edge px (host-computed; chain anchors here - ghostClearancePx). */
+    endX: number;
+    /** chainPulseMs from physics. */
+    pulseMs: number;
+    /** chainStaggerMs from physics. */
+    staggerMs: number;
+}
+export declare function ResizePillArrowChain(props: ResizePillArrowChainProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace ResizePillArrowChain {
+    var displayName: string;
+}
+export declare const _CHEVRON_COUNT_LOCK = 5;

package/lib/primitives/dashboard/ResizePill/ResizePillGhost.d.ts

@@ -0,0 +1,25 @@
+import { PillTarget } from './useResizePill';
+export interface ResizePillGhostProps {
+    visible: boolean;
+    currentTarget: PillTarget;
+    previewTarget: PillTarget;
+    /** Host card / chart frame current width (px). */
+    hostWidth: number;
+    /** Host card / chart frame target width (px) — host computes from currentTarget→previewTarget. */
+    targetWidth: number;
+    /** From DEFAULT_RESIZE_PILL_PHYSICS.ghostClearancePx. */
+    ghostClearancePx: number;
+    orientation: 'vertical' | 'horizontal';
+}
+/**
+ * Renders a dashed-outline overlay at `targetWidth` px. Width is driven by
+ * a `motion/react` MotionValue (no CSS `transition: width`); opacity-only
+ * enter/exit transition (matches GhostPreview.tsx pattern).
+ *
+ * Returns null when the ghost would be a no-op (not visible OR target equals
+ * current — there is nothing to preview).
+ */
+export declare function ResizePillGhost(props: ResizePillGhostProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace ResizePillGhost {
+    var displayName: string;
+}

package/lib/primitives/dashboard/ResizePill/ResizePillSizeTooltip.d.ts

@@ -0,0 +1,21 @@
+import { PillTarget } from './useResizePill';
+export interface ResizePillSizeTooltipProps {
+    visible: boolean;
+    currentTarget: PillTarget;
+    previewTarget: PillTarget;
+    /** Card variant uses 'directional'; chart variant uses 'sized'. */
+    mode: 'directional' | 'sized';
+    /**
+     * Whether the parent has opted into rendering this tooltip (D-10).
+     * Plumbed through for completeness; the gating is performed by the parent
+     * deciding to mount this component, but accepting the prop here lets unit
+     * tests assert on the showSizeTooltip contract without an extra wrapper.
+     * Not all callers pass this — defaults to true (component is mounted, so
+     * the caller has implicitly opted in).
+     */
+    showSizeTooltip?: boolean;
+}
+export declare function ResizePillSizeTooltip(props: ResizePillSizeTooltipProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace ResizePillSizeTooltip {
+    var displayName: string;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * ResizePill barrel — public surface for Plan 02 importability gate.
+ *
+ * Plan 02 Task 5 greps for the 9 symbols below in the @mt-gloss/ui d.ts.
+ * If any symbol is missing, the gate fails before Plans 03/04 begin wiring.
+ * (cycle-3 gemini HIGH fix.)
+ */
+export { ResizePill } from './ResizePill';
+export { useResizePill } from './useResizePill';
+export { DEFAULT_RESIZE_PILL_PHYSICS } from './resizePillPhysics';
+export type { ResizePillProps, ResizePillPreviewProps, } from './ResizePill';
+export type { UseResizePillArgs, UseResizePillReturn, PillPhase, PillTarget, PillButton, } from './useResizePill';
+export type { ResizePillPhysicsConfig } from './resizePillPhysics';

package/lib/primitives/dashboard/ResizePill/resizePillPhysics.d.ts

@@ -0,0 +1,33 @@
+/**
+ * resizePillPhysics — Phase 11.3 config tokens (D-08, D-06).
+ *
+ * STRICT SEPARATION from gridInteractionPhysics.ts (D-27 analog):
+ * cascade + envelope + spring constants stay in their existing modules
+ * (gridInteractionPhysics.ts owns Phase 23 cascade timings; resizePhysics.ts
+ * owns spring + hysteresis + cardWidthSpring). This module owns ONLY
+ * pill-specific geometry + timings.
+ *
+ * DO NOT add cardWidthSpring here — lives in resizePhysics.ts (D-27 invariant
+ * verified by negative test in __tests__/resizePillPhysics.test.ts).
+ *
+ * Source spec: .planning/imports/resize/resize-pill-design.md §Configuration
+ * tokens. D-06 = fadeGraceMs:180 (bounce-back grace). D-08 = pillOverhangPx:12
+ * (lands in 15px section gap at 3×1).
+ */
+export declare const DEFAULT_RESIZE_PILL_PHYSICS: {
+    readonly pillOverhangPx: 12;
+    readonly pillClearancePx: 14;
+    readonly ghostClearancePx: 10;
+    readonly pillButtonWidth: 30;
+    readonly pillButtonHeight: 26;
+    readonly triggerZoneWidth: 36;
+    readonly pillRevealMs: 180;
+    readonly pillDismissMs: 140;
+    readonly hoverHideGraceMs: 120;
+    readonly fadeGraceMs: 180;
+    readonly chevronExitMs: 160;
+    readonly checkEnterMs: 180;
+    readonly chainPulseMs: 1200;
+    readonly chainStaggerMs: 120;
+};
+export type ResizePillPhysicsConfig = typeof DEFAULT_RESIZE_PILL_PHYSICS;

package/lib/primitives/dashboard/ResizePill/useResizePill.d.ts

@@ -0,0 +1,37 @@
+import { ResizePillPhysicsConfig } from './resizePillPhysics';
+export type PillTarget = number | 'compact' | 'medium' | 'full';
+export type PillButton = 'shrink' | 'grow' | 'compact' | 'medium' | 'full';
+export type PillPhase = 'idle' | 'trigger-hover' | 'pill-visible' | 'pre-commit' | 'committing' | 'fading';
+export interface UseResizePillArgs {
+    currentTarget: PillTarget;
+    availableTargets: PillTarget[];
+    onCommit: (target: PillTarget) => void;
+    /** Mutex / global affordance gate. When true, all transitions to non-idle blocked. */
+    forceIdle?: boolean;
+    /** Phase observer (Plan 05 mutex consumes). */
+    onPhaseChange?: (phase: PillPhase) => void;
+    /** Optional override of the locked physics tokens (test/dev tuning panel). */
+    physics?: Partial<ResizePillPhysicsConfig>;
+}
+export interface UseResizePillReturn {
+    phase: PillPhase;
+    pillVisible: boolean;
+    /** D-05 — frozen during fade; resyncs to currentTarget only inside showPill. */
+    pillSpan: PillTarget;
+    /** Which button cursor is over — Plan 02 preview overlay gate. */
+    buttonHover: PillButton | null;
+    /** Resolved hover target; null when buttonHover is null OR equals currentTarget. */
+    previewTarget: PillTarget | null;
+    handlers: {
+        onTriggerEnter: () => void;
+        onTriggerLeave: () => void;
+        onPillEnter: () => void;
+        onPillLeave: () => void;
+        onButtonEnter: (target: PillTarget) => void;
+        onButtonLeave: () => void;
+        onButtonClick: (target: PillTarget) => void;
+    };
+    /** Direct programmatic commit — used by tests + ChartSlot direct teleport. */
+    commit: (target: PillTarget) => void;
+}
+export declare function useResizePill(args: UseResizePillArgs): UseResizePillReturn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mt-gloss/ui",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "type": "module",
   "publishConfig": {
     "access": "restricted"