@prolibu-suite/cobalt-core 0.6.0 → 0.8.0

package/dist/types/components/co-calendar-timegrid/co-calendar-timegrid.d.ts

@@ -0,0 +1,178 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * co-calendar-timegrid — the Week/Day time-grid. The shell renders it with
+ * `dates` = 7 day-keys (week) or 1 (day). Presentation + interaction only; the
+ * host owns data (CONTROLLED). All instant math is delegated to the engine — the
+ * only timezone boundary is the `timeZone` prop (wall-clock render).
+ */
+export declare class CoCalendarTimegrid {
+    el: HTMLElement;
+    events: NormalizedEvent[];
+    /** Visible day keys "YYYY-MM-DD" (7 = week, 1 = day). */
+    dates: string[];
+    locale: string;
+    timeZone: string;
+    editable: boolean;
+    selectable: boolean;
+    minDate?: string;
+    maxDate?: string;
+    slotMinutes: number;
+    snapMinutes: number;
+    defaultDurationMinutes: number;
+    scrollTime: string;
+    nowIndicator: boolean;
+    /** Cargando: en vez de los eventos pinta bloques skeleton en las columnas.
+     *  La grilla (eje de horas, líneas, cabecera de días, franja de todo-el-día)
+     *  se mantiene: lo único que todavía no se sabe son los eventos. */
+    loading: boolean;
+    allDaySlot: boolean;
+    minTime: string;
+    maxTime: string;
+    /** Minute of "now" for the indicator; refreshed on a 60s timer. */
+    nowMinutes: number;
+    nowDay: string;
+    /** Roving-tabindex focus position for keyboard navigation over slots. */
+    focusDate: string;
+    focusMin: number;
+    /** A time range was selected on an empty area (create request). */
+    coRangeSelect: EventEmitter<{
+        start: string;
+        end: string;
+        /** Viewport-anchored rect of the selected area, for the host to anchor a quick-create bubble. */
+        rect?: {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    coEventClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    coEventDrop: EventEmitter<{
+        id: string;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+    }>;
+    /** Doble activación de un chip (direct-edit request del host). */
+    coEventDblClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    selDate: string | null;
+    selStartMin: number;
+    selEndMin: number;
+    private selecting;
+    /** Coords crudas del último pointermove: el getBoundingClientRect corre UNA vez
+     * por frame, dentro del rAF (antes corría a ~120Hz, en el move crudo). */
+    private pendingSel;
+    private selRaf;
+    private pendingDrag;
+    private dragRaf;
+    private onWindowPointerUp;
+    dragId: string | null;
+    private dragMode;
+    private dragGrabOffsetMin;
+    private dragDurationMin;
+    private dragDate;
+    private dragStartMin;
+    private dragEndMin;
+    private origStartMin;
+    private origEndMin;
+    private origDate;
+    private suppressNextClick;
+    private dragArmedId;
+    private dragStartPointer;
+    private onWindowPointerMove;
+    private onWindowPointerUpDrag;
+    private nowTimer?;
+    private rootEl?;
+    private scrollEl?;
+    /** Ghost imperativo del drag: se posiciona con style directo, nunca por vdom. */
+    private ghostEl?;
+    /** Rects de las columnas cacheados AL AGARRAR: con esto el frame de drag es
+     * aritmética pura (antes: ~9 getBoundingClientRect + 2 querySelector/frame,
+     * que además forzaban reflow síncrono al escribir estilos en el mismo rAF). */
+    private colRects;
+    private gridRect;
+    private onDragViewportChange;
+    /** Memo de layoutTimeGrid/layoutAllDay/byId por identidad de inputs. */
+    private layoutCache?;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /** Limpia el resaltado persistente de selección (lo llama el host al cerrar
+     * su bubble/form de creación). */
+    clearSelection(): Promise<void>;
+    /** Un refetch (post-save) invalida la referencia visual de la selección. */
+    onEventsChange(): void;
+    private refreshNow;
+    private get minM();
+    private get maxM();
+    private scrollToInitial;
+    /** Visible day keys, with the same fallback the render uses. */
+    private visibleDates;
+    /** Slot size guarded: ahora alimenta un `calc()` (un 0/NaN dejaría la grilla
+     * sin altura, silenciosamente). */
+    private get slotM();
+    /** Number of slot rows in the visible window (drives the body height). */
+    private slotCount;
+    /** Hour marks inside the visible window — one axis label each (was 1 div per
+     * slot with a label only on the hour). */
+    private hourList;
+    /** Minutes-of-day at a clientY within a column element, snapped and clamped. */
+    private minutesFromPointer;
+    /** Same math as minutesFromPointer but over the cached grid rect (drag path):
+     * cero lecturas de layout por frame. */
+    private minutesFromCachedY;
+    private minutesAtFraction;
+    /** Snapshot de la geometría de columnas al empezar un drag. Se re-toma solo
+     * cuando el viewport cambia (scroll del body / resize), nunca por frame. */
+    private captureDragRects;
+    private bindDragViewportListeners;
+    /** Marca la interacción en el root (hover/hit-testing off en los chips). No es
+     * @State a propósito: no debe disparar un render por drag. */
+    private setInteracting;
+    /** Build an ISO instant (UTC) for a wall-clock minute-of-day on a given day. */
+    private toInstant;
+    private isDayInteractable;
+    private startSelection;
+    private extendSelection;
+    private finishSelection;
+    /** Viewport rect of the selected span, mirroring the `.tg__selection` ghost's
+     * fraction math over the column's own bounding box. Never throws: falls back to
+     * the whole-column rect, or undefined if the column isn't in the DOM. */
+    private selectionRect;
+    private eventById;
+    /** The day column under a clientX (week can drop across days) — resuelto por
+     * aritmética sobre los rects cacheados, sin tocar el DOM. */
+    private dateKeyAtX;
+    private startMove;
+    private startResize;
+    private beginDragInteraction;
+    /** Ghost del drag escrito DIRECTO al DOM: el vdom no participa (los campos del
+     * drag son privados a propósito — promoverlos a @State volvería a re-renderizar
+     * la grilla entera por frame). */
+    private paintGhost;
+    private hideGhost;
+    /** Igual que extendSelection: un solo apply por frame (ver comentario allí). */
+    private trackDrag;
+    private applyDrag;
+    private finishDrag;
+    /** Roving-tabindex keyboard nav: ↑/↓ by slot, ←/→ by day, Enter/Space to select. */
+    private handleKeyDown;
+    private shiftFocusDate;
+    private renderSelectionGhost;
+    private renderEventBox;
+    private renderAllDayBar;
+    /** Los 3 cómputos de layout del render, memoizados por IDENTIDAD de inputs
+     * (`events` llega memoizado del shell): un re-render por drag/now-tick/focus
+     * no vuelve a empaquetar la semana. */
+    private getLayouts;
+    render(): any;
+}

package/dist/types/components/co-carousel/co-carousel.d.ts

@@ -0,0 +1,85 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * A generic slide carousel. Coordinates light-DOM `co-carousel-item`
+ * children (same pattern as co-tab-group): the parent stamps aria and
+ * inertness on each item and translates a flex track to the active index.
+ *
+ * No v-model in the Vue wrappers — consume with `:value` + `@coSlideChange`.
+ *
+ * @slot - co-carousel-item elements
+ */
+export declare class CoCarousel {
+    el: HTMLElement;
+    /** Active slide index */
+    value: number;
+    /** Auto-advance slides */
+    autoplay: boolean;
+    /** Autoplay interval in milliseconds (floored at 1000) */
+    interval: number;
+    /** Wrap around at the ends */
+    loop: boolean;
+    /** Show prev/next arrows */
+    arrows: boolean;
+    /** Show dot indicators */
+    dots: boolean;
+    /** Pause autoplay while hovered */
+    pauseOnHover: boolean;
+    /** Enable pointer swipe navigation */
+    swipe: boolean;
+    /** Container aspect ratio */
+    aspectRatio: '16:9' | '4:3' | '1:1' | '21:9' | 'auto';
+    /** Language for aria labels (es/en/pt, accepts full locales) */
+    locale: string;
+    /** Emitted when the active slide changes (user, autoplay or method) */
+    coSlideChange: EventEmitter<number>;
+    private itemCount;
+    private dragDx;
+    private dragging;
+    /** True while the autoplay interval is actually running (drives aria-live). */
+    private rotating;
+    private timer?;
+    private hovering;
+    private focusWithin;
+    private reducedMotion;
+    private motionQuery?;
+    private pointerStartX;
+    private pointerStartY;
+    private pointerId;
+    private suppressClick;
+    private viewportEl?;
+    /** Minimum horizontal travel (px) before a pointer gesture counts as a drag. */
+    private static readonly DRAG_SLOP;
+    /** Horizontal travel (px) needed to change slide on release. */
+    private static readonly SWIPE_THRESHOLD;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    watchValue(): void;
+    watchLocale(): void;
+    watchAutoplay(): void;
+    next(): Promise<void>;
+    prev(): Promise<void>;
+    goTo(index: number): Promise<void>;
+    private getItems;
+    private refreshItems;
+    private syncItems;
+    private handleSlotChange;
+    private clampIndex;
+    private setActive;
+    private advance;
+    private restartAutoplay;
+    private stopAutoplay;
+    private handleVisibilityChange;
+    private handleMotionChange;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleFocusIn;
+    private handleFocusOut;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private handleClickCapture;
+    private handleKeyDown;
+    render(): any;
+}

package/dist/types/components/co-carousel-item/co-carousel-item.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A single slide inside a co-carousel. The parent carousel stamps
+ * aria-label / aria-hidden / inert on each item (same light-DOM
+ * coordination pattern as co-tab-group ↔ co-tab).
+ *
+ * @slot - Slide content
+ */
+export declare class CoCarouselItem {
+    render(): any;
+}

package/dist/types/components/co-date-picker/co-date-picker.d.ts

@@ -33,6 +33,13 @@ export declare class CoDatePicker {
     placeholder?: string;
     /** Field size, forwarded to the inner co-date-field. */
     size: 's' | 'sm' | 'md' | 'lg';
+    /** Visual style. `flat` strips the inner co-date-field's border and
+     *  background so it reads as plain content instead of a boxed control —
+     *  padding, label, focus ring, disabled and invalid states are unaffected.
+     *  `default` (the standard bordered box) renders identically to before
+     *  this prop existed. co-date-field itself has no `variant` prop, so this
+     *  is applied from the outside via `::part(field)` — see co-date-picker.css. */
+    variant: 'default' | 'flat';
     name?: string;
     disabled: boolean;
     readonly: boolean;

package/dist/types/components/co-date-range-picker/co-date-range-picker.d.ts

@@ -54,6 +54,11 @@ export declare class CoDateRangePicker {
     layout: 'vertical' | 'horizontal';
     /** Trigger size (mirrors co-input): s 28 / sm 32 / md 40 / lg 48. */
     size: 's' | 'sm' | 'md' | 'lg';
+    /** Visual style. `flat` strips the trigger's border and background so it
+     *  reads as plain content instead of a boxed control — padding, label,
+     *  focus ring, disabled and invalid states are unaffected. `default` (the
+     *  standard bordered box) renders identically to before this prop existed. */
+    variant: 'default' | 'flat';
     placement: Placement;
     open: boolean;
     applyLabel?: string;

package/dist/types/components/co-date-time-picker/co-date-time-picker.d.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { Placement } from '../../utils/positioning';
+/**
+ * Date + TIME picker: one field, one popover. Composes `co-popover` (floating
+ * panel, outside-click) + `co-calendar` (day grid) + a scrollable list of times
+ * beside it — the Google Calendar layout.
+ *
+ * VALUE CONTRACT — the committed `value` is a UTC ISO instant
+ * ("2026-07-25T21:30:00.000Z"), never a wall-clock string. The wall clock the
+ * user sees and edits is rendered in `timeZone` (IANA; browser zone when
+ * omitted). All ISO↔wall-clock conversion goes through the calendar engine
+ * (`@prolibu-suite/cobalt-calendar-utils`), so DST comes from the platform tz
+ * database — the same boundary `co-calendar-timegrid` uses. A date-only value
+ * ("2026-07-25") is NOT an instant: it is read as that wall-clock day in
+ * `timeZone` at {@link DEFAULT_MINUTES} (09:00), never as UTC midnight (which
+ * would shift the day west of UTC).
+ *
+ * INTERACTION (Google):
+ *   - Click the field → opens. Picking a DAY commits and keeps the panel open
+ *     (you almost always want to set the hour next); picking a TIME commits and
+ *     closes. So there is no draft/apply step and no confirm button.
+ *   - ArrowDown on the field → moves focus into the calendar grid.
+ *   - The time list is a listbox: Arrow/Home/End/PageUp/PageDown move the active
+ *     option, Enter/Space selects it.
+ *   - Escape → closes and returns focus to the field. Outside click → closes.
+ *
+ * Escape is owned here (co-popover `closeOnEscape=false`) so focus can return to
+ * the field; outside-click stays with co-popover.
+ *
+ * @part field - The bordered trigger row
+ * @part label - The field label
+ * @part display - The button that shows the formatted value
+ * @part clear - The clear button
+ * @part helper - The helper/error text row
+ */
+export declare class CoDateTimePicker {
+    el: HTMLElement;
+    /** Committed value: UTC ISO instant ("2026-07-25T21:30:00.000Z") or null. */
+    value: string | null;
+    /** IANA zone the wall clock is rendered in. Defaults to the browser zone. */
+    timeZone?: string;
+    /** Minutes between consecutive options in the time list. */
+    stepMinutes: number;
+    /** 12-hour clock (Google style). `false` renders a 24h clock. */
+    hour12: boolean;
+    /** Earliest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    min?: string;
+    /** Latest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    max?: string;
+    disabledDates?: string[] | string;
+    disabledDaysOfWeek?: number[] | string;
+    locale: string;
+    /** Date part of the trigger text (tokens yyyy/yy/MMMM/MMM/MM/M/dd/d). */
+    displayFormat: string;
+    firstDayOfWeek: number;
+    label?: string;
+    placeholder?: string;
+    /** Field size, mirrors co-input/co-date-field: s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
+    /** `flat` strips the trigger's border/background so it reads as content. */
+    variant: 'default' | 'flat';
+    name?: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    clearable: boolean;
+    invalid: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside). */
+    layout: 'vertical' | 'horizontal';
+    /** Popover placement relative to the field. */
+    placement: Placement;
+    /** Whether the panel is open. */
+    open: boolean;
+    /** Max viewport width (px) that renders the panel as a bottom sheet. */
+    mobileBreakpoint: number;
+    /** True when the viewport is at/under `mobileBreakpoint`. */
+    isMobile: boolean;
+    /** Minutes-of-day highlighted by the keyboard in the time list. */
+    activeMinutes: number;
+    /** Committed instant (UTC ISO) or null. */
+    coChange: EventEmitter<string | null>;
+    coClear: EventEmitter<void>;
+    coFocus: EventEmitter<void>;
+    coBlur: EventEmitter<void>;
+    coOpen: EventEmitter<void>;
+    coClose: EventEmitter<void>;
+    private popoverEl?;
+    private calendarEl?;
+    private triggerBtn?;
+    private listEl?;
+    private pendingFocusGrid;
+    private pendingFocusTrigger;
+    /** 'center' when the list is (re)opened, 'nearest' while arrowing through it. */
+    private pendingScroll;
+    private mql?;
+    private mqlHandler;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onOpenChange(next: boolean): void;
+    private get zone();
+    private get isInvalid();
+    /** Wall clock of the committed value in `zone`, or null when empty/invalid. */
+    private get parts();
+    /** Calendar bounds are date-only; accept an instant and reduce it to its day. */
+    private dayBound;
+    private setOpen;
+    /** Write day+minutes as a UTC instant and notify. */
+    private commit;
+    private onTriggerKeyDown;
+    private onClearClick;
+    private onCalendarSelect;
+    private pickTime;
+    private onListKeyDown;
+    private onPopoverOpen;
+    private onPopoverClose;
+    private onRootKeyDown;
+    private focusGridSoon;
+    private scrollActiveIntoView;
+    componentDidRender(): void;
+    private get step();
+    /** Grid of minutes-of-day, plus the committed hour when it falls off-grid
+     *  (an imported 16:37 meeting must stay visible and selectable). */
+    private get options();
+    private renderTrigger;
+    private renderPanel;
+    private renderHelper;
+    private renderLabel;
+    render(): any;
+}

package/dist/types/components/co-event-calendar/co-event-calendar.d.ts

@@ -4,8 +4,8 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * co-event-calendar — the public entry point of the Cobalt Calendars family.
  *
  * Owns view state, the visible anchor date, event normalization and the toolbar,
- * and delegates rendering to the active view (Phase 1: month). All hard math
- * lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
+ * and delegates rendering to the active view (month/week/day; agenda pending).
+ * All hard math lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
  * calendar emits requests (`coEventDrop`, `coDateSelect`) and the host applies
  * them by updating the `events` prop — leaving it unchanged on failure is the
  * revert.
@@ -16,8 +16,16 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * @part toolbar - The header toolbar
  * @part body - The active view container
  */
+type StatusColorsProp = Record<string, {
+    backgroundColor?: string;
+    borderColor?: string;
+}> | string;
 export declare class CoEventCalendar {
-    /** Active view. Phase 1 ships `month`; week/day/agenda land in later phases. */
+    el: HTMLElement;
+    /** Limpia el resaltado persistente de selección de la vista activa (timegrid
+     * o month) — lo llama el host al cerrar su bubble/form de creación. */
+    clearRangeSelection(): Promise<void>;
+    /** Active view. `month`/`week`/`day` are implemented; `agenda` is pending. */
     view: 'month' | 'week' | 'day' | 'agenda';
     /** Anchor date "YYYY-MM-DD" controlling the visible period. Persisted by host. */
     date?: string;
@@ -42,23 +50,45 @@ export declare class CoEventCalendar {
     /** Views offered in the switcher. Defaults to the implemented set. */
     availableViews: string[] | string;
     /** Optional status→{backgroundColor,borderColor} map (object or JSON string). */
-    statusColors?: Record<string, {
-        backgroundColor?: string;
-        borderColor?: string;
-    }> | string;
+    statusColors?: StatusColorsProp;
     /** Default minutes for a timed event missing an end. */
     defaultDurationMinutes: number;
+    /** Show the all-day lane in week/day views. */
+    allDaySlot: boolean;
+    /** Visible-hours window for week/day (minutes-of-day bounds as "HH:mm"). */
+    minTime: string;
+    maxTime: string;
+    /** Slot/snap granularity (minutes) for week/day. */
+    slotMinutes: number;
+    snapMinutes: number;
+    /** Initial scroll position for week/day ("HH:mm"). */
+    scrollTime: string;
+    /** Show the current-time indicator in week/day. */
+    nowIndicator: boolean;
+    /** Cargando eventos: se propaga a la grilla (mes/timegrid), que reemplaza
+     *  SUS chips por bloques skeleton y conserva toda su estructura — bordes,
+     *  cabecera de días, eje de horas. El toolbar sigue operable y nada se
+     *  desmonta, así no se pierde el scroll de semana/día. */
+    loading: boolean;
     /** Internal anchor (YYYY-MM-DD) — mirrors `date`, defaults to today. */
     anchor: string;
     /** An event chip was activated. */
     coEventClick: EventEmitter<{
         event: NormalizedEvent;
+        rect: DOMRect | null;
     }>;
     /** A date/range was selected (create request). */
     coDateSelect: EventEmitter<{
         start: string;
         end: string;
         allDay: boolean;
+        /** Viewport-anchored rect of the selected day/range, for the host to anchor a quick-create bubble. */
+        rect: DOMRect | {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        } | null;
     }>;
     /** An event was dragged to a new time (move). `revert` is a host convenience. */
     coEventDrop: EventEmitter<{
@@ -70,6 +100,11 @@ export declare class CoEventCalendar {
         allDay: boolean;
         revert: () => void;
     }>;
+    /** An event chip was double-activated (direct-edit request). */
+    coEventDblClick: EventEmitter<{
+        event: NormalizedEvent;
+        rect: DOMRect | null;
+    }>;
     /** The visible period changed → host should refetch and persist the view pref. */
     coDatesSet: EventEmitter<{
         view: string;
@@ -90,9 +125,24 @@ export declare class CoEventCalendar {
     componentDidLoad(): void;
     onDateChange(value?: string): void;
     private get tz();
+    /**
+     * Memo for the `normalized` getter below. Re-normalizing on every access is
+     * wasted work (render reads it twice) AND, since `normalizeEvents` always
+     * returns a fresh array, breaks referential-equality memos downstream that
+     * depend on a stable `events` reference (layout/packing caching). Keyed by
+     * the raw prop identities that feed normalization — `events`/`statusColors`
+     * are compared by `===` (stable array/string/object reference from the
+     * host unless it actually changed), `defaultDurationMinutes` by value.
+     */
+    private _normCache?;
     private get normalized();
     private get viewsList();
-    /** Visible [start, end) of the current month view, as date strings. */
+    /** Sunday=0 UTC day-of-week of a date-only key (tz-independent). */
+    private dowOf;
+    private weekStart;
+    /** Day keys the active view renders: 7 for week, 1 for day, [] for month. */
+    private get visibleDates();
+    /** Visible [start, end) of the active view, as date strings. */
     private visibleRange;
     private emitDatesSet;
     private setAnchor;
@@ -102,9 +152,12 @@ export declare class CoEventCalendar {
     private step;
     private switchView;
     private handleDaySelect;
+    private handleRangeSelect;
     private handleEventClick;
+    private handleEventDblClick;
     private handleEventDrop;
     private handleMoreClick;
     private title;
     render(): any;
 }
+export {};

package/dist/types/components/co-event-popover/co-event-popover.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type Placement } from '../../utils/positioning';
+/**
+ * co-event-popover — anchored detail card (Google-Calendar-style) for a calendar
+ * event. Non-modal, dismissible. Anchors to a viewport `anchorRect` (the chip's
+ * getBoundingClientRect), promotes to the top-layer (the calendar shell has
+ * contain:layout ancestors that re-anchor position:fixed), and closes on Escape /
+ * outside-click. Content is slotted by the host (suite-v2 fills the meeting fields).
+ */
+export declare class CoEventPopover {
+    el: HTMLElement;
+    open: boolean;
+    /** Anchor rect in viewport coords (chip.getBoundingClientRect()). */
+    anchorRect?: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    placement: Placement;
+    /** Accent color for the leading dot (event color). */
+    color?: string;
+    /** Render the leading color dot. Set false for dot-less content (quick-create). */
+    dot: boolean;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    /** Accessible name for the panel (role="dialog" needs one). */
+    popoverLabel?: string;
+    coClose: EventEmitter<void>;
+    private panelEl?;
+    private prevFocus?;
+    componentDidLoad(): void;
+    onOpenChange(v: boolean): void;
+    onAnchorChange(): void;
+    disconnectedCallback(): void;
+    private promoteAndPosition;
+    private dismissPanel;
+    private teardownListeners;
+    private position;
+    private onScroll;
+    private onKeydown;
+    private onPointerDown;
+    private requestClose;
+    render(): any;
+}

package/dist/types/components/co-fab/co-fab.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 export declare class CoFab {
+    el: HTMLElement;
     icon: string;
     label?: string;
     variant: 'primary' | 'secondary' | 'stroke';
@@ -9,7 +10,12 @@ export declare class CoFab {
     disabled: boolean;
     /** Fixed position on screen */
     position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left' | 'none';
+    /** With `label`: icon-only circle at rest that stretches into the extended
+     *  pill on hover/focus-visible (springy "liquid" morph). */
+    expandOnHover: boolean;
     coClick: EventEmitter<void>;
+    private labelEl?;
     private handleClick;
+    private handleExpandMeasure;
     render(): any;
 }

package/dist/types/components/co-input/co-input.d.ts

@@ -52,6 +52,11 @@ export declare class CoInput {
      *  In the filled search-pill variant (`fill`) this drives the pill height
      *  instead (s ≈ 38px). */
     size: 's' | 'sm' | 'md' | 'lg';
+    /** Visual style. `flat` strips the field's border and background so it
+     *  reads as plain content instead of a boxed input — padding, label, focus
+     *  ring, disabled and status states are unaffected. `default` (the
+     *  standard bordered box) renders identically to before this prop existed. */
+    variant: 'default' | 'flat';
     /** Filled search-pill variant. When true the field renders as a minimal gray
      *  pill (background gray-100, no border/box-shadow, 10px radius) with a search
      *  glyph on the left and a plain-`x` clear — the floating label, helper text and

package/dist/types/components/co-lightbox/co-lightbox.d.ts

@@ -63,6 +63,13 @@ export declare class CoLightbox {
     connectedCallback(): void;
     disconnectedCallback(): void;
     componentDidRender(): void;
+    /** Root element (popover="manual") — promoted to the TOP LAYER while open.
+     *  z-index cannot beat top-layer surfaces (co-overlay promotes the modal
+     *  drawer's scrim+card via popover), so the viewer must live there too:
+     *  top-layer paint order = promotion order, and the lightbox opens last. */
+    private rootEl?;
+    private demoteTimer?;
+    private syncTopLayer;
     onOpenChange(open: boolean): void;
     onStartIndexChange(v: number): void;
     onImagesChange(): void;

package/dist/types/components/co-menu-item/co-menu-item.d.ts

@@ -21,6 +21,9 @@ export declare class CoMenuItem {
     iconSize?: number;
     /** Text shown in the row. */
     label?: string;
+    /** Optional second line under the label (muted, smaller) — e.g. what an
+     *  export method means. The row auto-grows (min-height, not height). */
+    caption?: string;
     /** Tighter row metrics (32px instead of 36px). */
     dense: boolean;
     /** Marks the row as selected — paints an at-rest gray-100 background. Used by