@prolibu-suite/cobalt-core 0.2.0 → 0.4.0

package/dist/esm/tz-B6JZk8fL.js

@@ -0,0 +1,119 @@
+/**
+ * tz.ts — IANA timezone conversion for the Cobalt calendar engine.
+ *
+ * The calendar STORES instants as UTC ISO-8601 ("…Z") and RENDERS wall-clock
+ * time in a target IANA zone. Browsers expose exactly one tz-correct primitive:
+ * `Intl.DateTimeFormat` with a `timeZone` option. Everything here is built on
+ * it, with ZERO dependencies, so DST is resolved by the platform's tz database
+ * (kept current by the OS) rather than a bundled rule set.
+ *
+ * Vocabulary:
+ *   - an "instant" is a point in time: epoch milliseconds, a Date, or an ISO
+ *     string WITH an offset/Z designator (date-time strings parse unambiguously;
+ *     bare "YYYY-MM-DD" is NOT an instant — see {@link model.ts} all-day events).
+ *   - a "wall clock" is the calendar-and-clock reading a person standing in
+ *     `timeZone` would see at that instant.
+ *
+ * Why not `new Date(str)` everywhere: that is only safe for date-TIME strings
+ * carrying an offset (which is all this module accepts). Bare date-only strings
+ * parse as UTC midnight and shift the day in negative-offset zones — that hazard
+ * is owned by `@prolibu-suite/cobalt-date-utils`, never here.
+ */
+const pad2 = (n) => String(n).padStart(2, '0');
+const FMT_CACHE = new Map();
+/** Cached parts formatter for a zone (constructing Intl.DateTimeFormat is costly). */
+function partsFormatter(timeZone) {
+    let f = FMT_CACHE.get(timeZone);
+    if (!f) {
+        f = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        FMT_CACHE.set(timeZone, f);
+    }
+    return f;
+}
+/** Normalize any {@link Instant} to epoch milliseconds. */
+function toEpoch(instant) {
+    if (typeof instant === 'number')
+        return instant;
+    if (instant instanceof Date)
+        return instant.getTime();
+    const t = Date.parse(instant);
+    if (Number.isNaN(t))
+        throw new RangeError(`tz: invalid instant "${instant}"`);
+    return t;
+}
+/** The browser's current IANA timezone (e.g. "America/Bogota"). */
+function getLocalTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+/** The wall-clock reading at `instant`, observed in `timeZone`. */
+function getWallClock(instant, timeZone) {
+    const parts = partsFormatter(timeZone).formatToParts(new Date(toEpoch(instant)));
+    const read = (type) => {
+        const p = parts.find((x) => x.type === type);
+        return p ? Number(p.value) : 0;
+    };
+    let hour = read('hour');
+    // Defensive: some engines emit "24" for midnight under hour-cycle edge cases.
+    if (hour === 24)
+        hour = 0;
+    return {
+        year: read('year'),
+        month: read('month'),
+        day: read('day'),
+        hour,
+        minute: read('minute'),
+        second: read('second'),
+    };
+}
+/**
+ * Minutes EAST of UTC at `instant`, observed in `timeZone`.
+ * America/Bogota → -300 (UTC-5); America/New_York in summer → -240 (UTC-4).
+ */
+function getOffsetMinutes(instant, timeZone) {
+    const epoch = toEpoch(instant);
+    const wc = getWallClock(epoch, timeZone);
+    const asUTC = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour, wc.minute, wc.second);
+    return Math.round((asUTC - epoch) / 60000);
+}
+/**
+ * Convert a wall-clock reading INTERPRETED in `timeZone` to a UTC instant.
+ *
+ * Handles DST: the offset is sampled at a first guess, applied, then re-sampled
+ * because the offset that applies depends on the very instant we're computing.
+ * A single correction step resolves every regular DST transition. In a
+ * spring-forward gap (a wall time that never existed) this yields the consistent
+ * post-transition instant; in a fall-back overlap it yields the first (earlier)
+ * occurrence — both are deterministic, documented conventions.
+ */
+function wallClockToEpoch(wc, timeZone) {
+    const guess = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour ?? 0, wc.minute ?? 0, wc.second ?? 0);
+    const off1 = getOffsetMinutes(guess, timeZone);
+    const utc1 = guess - off1 * 60000;
+    const off2 = getOffsetMinutes(utc1, timeZone);
+    return off2 === off1 ? utc1 : guess - off2 * 60000;
+}
+/** Canonical UTC "…Z" string for any instant. */
+function toUtcISO(instant) {
+    return new Date(toEpoch(instant)).toISOString();
+}
+/** Wall-clock date key "YYYY-MM-DD" at `instant` in `timeZone` (for day bucketing). */
+function zonedDateKey(instant, timeZone) {
+    const wc = getWallClock(instant, timeZone);
+    return `${wc.year}-${pad2(wc.month)}-${pad2(wc.day)}`;
+}
+/** Minutes since local midnight at `instant` in `timeZone` (for time-grid layout). */
+function zonedMinutesOfDay(instant, timeZone) {
+    const wc = getWallClock(instant, timeZone);
+    return wc.hour * 60 + wc.minute;
+}
+
+export { toUtcISO as a, zonedMinutesOfDay as b, getWallClock as c, getLocalTimeZone as g, toEpoch as t, wallClockToEpoch as w, zonedDateKey as z };

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

@@ -17,6 +17,8 @@ export declare class CoAutocomplete {
     helperText?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input): s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     /** Pre-loaded or server-returned options */
     options: AutocompleteOption[] | string[] | string;

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

@@ -7,6 +7,8 @@ export declare class CoAvatar {
     text?: string;
     /** Image URL (type="image") */
     src?: string;
+    /** Alternative text for the image (type="image"); falls back to text when unset */
+    alt?: string;
     /** Phosphor icon name (type="icon"), defaults to "user" */
     icon: string;
     /** Icon weight */
@@ -15,6 +17,8 @@ export declare class CoAvatar {
     shape: 'circle' | 'square';
     /** Custom background color (hex or CSS value) */
     color?: string;
+    /** Optional 2px ring color (hex/CSS). Drives the inset ::after ring. */
+    ringColor?: string;
     imgFailed: boolean;
     private handleImgError;
     render(): any;

package/dist/types/components/co-avatar-group/co-avatar-group.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/** One avatar descriptor consumed by `co-avatar-group`. Mirrors `co-avatar`'s props. */
+export interface CoAvatarGroupItem {
+    type?: 'text' | 'icon' | 'image';
+    text?: string;
+    src?: string;
+    icon?: string;
+    color?: string;
+    shape?: 'circle' | 'square';
+    /** Full name — used to compose the group's accessible label. */
+    name?: string;
+    /** Optional ring color forwarded to the child `co-avatar`. */
+    ringColor?: string;
+}
+export declare class CoAvatarGroup {
+    /** Avatar descriptors rendered as an overlapping stack. */
+    items: CoAvatarGroupItem[];
+    /** Max avatars shown before the remainder collapses into a "+N" badge. `0` = show all. */
+    max: number;
+    /** Size forwarded to every avatar (and the overflow badge). */
+    size: 'xl' | 'lg' | 'md' | 'sm' | 'xs' | 'xxs';
+    /** Shape forwarded to every avatar that doesn't set its own. */
+    shape: 'circle' | 'square';
+    /** Make the whole group a focusable button (role=button, keyboard, coClick). */
+    interactive: boolean;
+    /** Accessible label override; when absent it's composed from the items' names. */
+    label?: string;
+    /** Emitted on click / Enter / Space when `interactive`. Does NOT bubble. */
+    coClick: EventEmitter<void>;
+    private activate;
+    private accessibleLabel;
+    render(): any;
+}

package/dist/types/components/co-bottom-sheet/co-bottom-sheet.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Mobile bottom sheet with native drag physics: the sheet follows the finger
+ * 1:1 downward, a fast flick (or a slow release past ~45% of its height)
+ * dismisses it, upward overdrag rubber-bands, and the backdrop opacity is
+ * coupled to the drag. The body scrolls internally — dragging from the body
+ * only engages when its content is scrolled to the top.
+ *
+ * Height fits the content, capped by `maxHeight` (default 85dvh).
+ *
+ * @slot header - Custom header content (overrides `heading`). Dragging it moves the sheet.
+ * @slot        - Sheet body (scrollable).
+ * @slot footer - Pinned action area below the body (outside the scroll), with safe-area padding.
+ */
+export declare class CoBottomSheet {
+    el: HTMLElement;
+    /** Whether the sheet is visible */
+    open: boolean;
+    /** Sheet title (used when the `header` slot is empty) */
+    heading: string;
+    /** Maximum sheet height (any CSS length; content shorter than this hugs) */
+    maxHeight: string;
+    /** Allow closing with the drag gesture. When false, drags rubber-band back. */
+    dismissible: boolean;
+    /** Close when tapping the backdrop */
+    closeOnOverlay: boolean;
+    /** Close when pressing Escape */
+    closeOnEscape: boolean;
+    /** Show the grab handle */
+    showHandle: boolean;
+    /** Requested to close (gesture, backdrop, Esc). Consumer should set `open=false`. */
+    coClose: EventEmitter<void>;
+    /** Transitioned to open=true. */
+    coOpen: EventEmitter<void>;
+    /** Slide-in animation finished. */
+    coAfterOpen: EventEmitter<void>;
+    /** Slide-out animation finished. */
+    coAfterClose: EventEmitter<void>;
+    hasFooter: boolean;
+    hasHeaderSlot: boolean;
+    private sheetEl?;
+    private backdropEl?;
+    private bodyEl?;
+    private tracker;
+    private armed;
+    private engaged;
+    private fromBody;
+    private startY;
+    private startX;
+    private startScrollTop;
+    private sheetHeight;
+    private dismissPending;
+    private dismissFallback?;
+    private pendingAfter;
+    onOpenChange(next: boolean, prev: boolean): void;
+    handleKey(e: KeyboardEvent): void;
+    disconnectedCallback(): void;
+    private clearInlineStyles;
+    private handleBackdropClick;
+    private slotHasContent;
+    private handleFooterSlotChange;
+    private handleHeaderSlotChange;
+    private handleTransitionEnd;
+    private handleGripPointerDown;
+    private handleBodyPointerDown;
+    private arm;
+    private handlePointerMove;
+    private engage;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private disarm;
+    /**
+     * iOS: `touch-action` is frozen at gesture start and preventDefault on
+     * pointermove does not stop native scrolling — only a non-passive touchmove
+     * listener can claim the gesture from a scrollable body.
+     */
+    private touchBlocker;
+    private attachTouchBlocker;
+    private detachTouchBlocker;
+    render(): any;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Horizontal breadcrumb trail. Accepts `co-breadcrumb-item` children via the
+ * default slot, or auto-renders them from the `items` JSON prop.
+ *
+ * The separator between crumbs is drawn by each `co-breadcrumb-item` as a
+ * leading icon (hidden on the first crumb via CSS), so no separator markup is
+ * interleaved here. This component propagates its `separator` prop down to the
+ * slotted items and layouts them in a `align-items:center; gap:4px` flex row.
+ */
+export declare class CoBreadcrumb {
+    el: HTMLElement;
+    /** Icon name (Phosphor) for the separator between crumbs. Propagated to
+     *  slotted `co-breadcrumb-item` children. */
+    separator: string;
+    /** Optional JSON array to auto-render crumbs instead of using the slot, e.g.
+     *  `[{ "label": "Mi unidad", "icon": "cloud", "value": "root" }]`. The last
+     *  entry is marked `current`. When set, slotted children are ignored. */
+    items?: string;
+    watchSeparator(): void;
+    componentDidLoad(): void;
+    private handleSlotChange;
+    /** Push the current `separator` onto every slotted (light-DOM) crumb. Items
+     *  auto-rendered from `items` get it directly in render() instead. */
+    private propagateSeparator;
+    private parseItems;
+    render(): any;
+}

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

@@ -0,0 +1,33 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * A single navigable crumb inside a `co-breadcrumb`.
+ *
+ * Renders a leading separator icon (hidden on the first crumb via CSS
+ * `:host(:first-child)`) followed by the clickable content — an optional
+ * leading icon and the label. Clicking (or Enter/Space) emits `coSelect` with
+ * the crumb's `value` (falling back to its `label`).
+ *
+ * Conventions mirror `co-menu-item`: the `current` crumb paints medium weight +
+ * text-default ink; earlier crumbs are regular weight + muted (gray-500).
+ */
+export declare class CoBreadcrumbItem {
+    /** Text shown in the crumb. */
+    label?: string;
+    /** Value emitted by `coSelect`. Falls back to `label` when unset. */
+    value?: string;
+    /** Optional leading icon (Phosphor name), size 16, inherits the crumb color. */
+    icon?: string;
+    /** Marks this crumb as the current (last) page — medium weight + text-default ink. */
+    current: boolean;
+    /** Leading separator icon (size 13, gray-400). Hidden on the first crumb via
+     *  CSS. Set by the parent `co-breadcrumb`; defaults to `caret-right`. */
+    separator: string;
+    /** Fired on click / Enter / Space with `value || label`. Bubbles + composed so
+     *  consumers can listen on the parent `co-breadcrumb`. */
+    coSelect: EventEmitter<string>;
+    el: HTMLElement;
+    private emit;
+    private handleClick;
+    private handleKeydown;
+    render(): any;
+}

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

@@ -3,11 +3,15 @@
  */
 export declare class CoButton {
     /** Visual style */
-    variant: 'primary' | 'secondary' | 'stroke' | 'ghost';
+    variant: 'primary' | 'secondary' | 'stroke' | 'ghost' | 'danger' | 'success';
     /** Shape: pill or straight corners */
     shape: 'rounded' | 'square';
     /** Size */
     size: 'l' | 'm' | 's' | 'xs';
+    /** Raised elevation — with variant="secondary" renders a white raised button (shadow-sm + inset hairline). */
+    elevated: boolean;
+    /** Surface the button sits on. On "dark", ghost/stroke variants switch to white ink + blanco-16 hover. */
+    surface: 'light' | 'dark';
     /** Disabled state */
     disabled: boolean;
     /** Text label (alternative to default slot) */
@@ -24,6 +28,8 @@ export declare class CoButton {
     color?: string;
     /** Custom text/icon color (CSS value or token, e.g. "var(--co-color-base-blanco)") */
     textColor?: string;
+    /** Override the size-derived glyph px (e.g. 24). Falls back to the size default. */
+    iconSize?: number;
     el: HTMLElement;
     private handleClick;
     render(): any;

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

@@ -0,0 +1,83 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * Month grid for the event calendar. Forks the day grid, roving-tabindex and
+ * keyboard model from `co-calendar`, then overlays multi-day event bars laid out
+ * by `layoutMonth` from the engine. Presentation + interaction only; the host
+ * (via `co-event-calendar`) owns data and persistence.
+ *
+ * Events are CONTROLLED through the `events` prop — drag emits a request, it does
+ * NOT mutate locally; the host re-renders with new data on success or leaves the
+ * old data on failure (that IS the revert).
+ *
+ * @part grid - The month grid container
+ */
+export declare class CoCalendarMonth {
+    el: HTMLElement;
+    /** Normalized events to render (from the engine's `normalizeEvents`). */
+    events: NormalizedEvent[];
+    /** Year shown. */
+    year: number;
+    /** Month shown (1-12). */
+    month: number;
+    /** BCP-47 locale for weekday labels. */
+    locale: string;
+    /** First day of week, 0=Sun..6=Sat. */
+    firstDayOfWeek: number;
+    /** IANA timezone used to place timed events on their wall-clock day. */
+    timeZone: string;
+    /** Earliest interactable day "YYYY-MM-DD" (gates select/drag — past-block). */
+    minDate?: string;
+    /** Latest interactable day "YYYY-MM-DD". */
+    maxDate?: string;
+    /** Master interaction gate. */
+    editable: boolean;
+    /** Allow empty-day click to request a create. */
+    selectable: boolean;
+    /** Max event lanes per day before "+N more". */
+    maxLanes: number;
+    /** Day holding roving focus. */
+    focused: string;
+    /** Day currently hovered while dragging an event. */
+    dragOverDate: string | null;
+    /** Id of the event being dragged. */
+    dragId: string | null;
+    /** Emitted when an empty day is selected (create request). Detail = "YYYY-MM-DD". */
+    coDaySelect: EventEmitter<{
+        date: string;
+    }>;
+    /** Emitted when an event chip is activated. */
+    coEventClick: EventEmitter<{
+        id: string;
+    }>;
+    /** Emitted on a completed drag-move (day granularity). */
+    coEventDrop: EventEmitter<{
+        id: string;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+    }>;
+    /** Emitted when the "+N more" affordance is activated. */
+    coMoreClick: EventEmitter<{
+        date: string;
+    }>;
+    private onPointerUp;
+    componentWillLoad(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private defaultFocus;
+    private get matrix();
+    private eventById;
+    private isDayInteractable;
+    private selectDay;
+    private activateEvent;
+    private moveFocus;
+    private focusCell;
+    private handleKeyDown;
+    private startDrag;
+    private finishDrag;
+    private renderChip;
+    render(): any;
+}

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

@@ -4,14 +4,22 @@ export declare class CoCheckbox {
     checked: boolean;
     /** Indeterminate state (partial selection) — visual only, overrides checked appearance */
     indeterminate: boolean;
-    /** Size: small=16px, large=24px */
-    size: 'small' | 'large';
+    /** Size: small=16px, medium=20px, large=24px (overlay appearance: small=20px, medium/large=22px) */
+    size: 'small' | 'medium' | 'large';
     /** Disabled state */
     disabled: boolean;
     /** Label text displayed beside the checkbox */
     label?: string;
     /** Value for checkbox group usage */
     value: string;
+    /** Accent fill color used when checked/indeterminate. Defaults to the current design token. */
+    onColor?: string;
+    /**
+     * Visual appearance:
+     * - 'default' — the standard labeled form checkbox (unchanged).
+     * - 'overlay' — a standalone frosted rounded selection chip (Drive), no label, bespoke SVG glyphs.
+     */
+    appearance: 'default' | 'overlay';
     /** Fired when the value changes */
     coChange: EventEmitter<boolean>;
     private handleClick;

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

@@ -16,20 +16,37 @@ export declare class CoChip {
      * - both    = icon before + icon after (Figma "2nd Icon")
      */
     iconMode: 'none' | 'left' | 'both';
-    /** Visual variant */
-    variant: 'filled' | 'outlined';
+    /** Visual variant.
+     *  - filled/outlined = existing tag/chip looks (unchanged defaults).
+     *  - filter = Cloud Drive filter-trigger pill (white pill, inset hairline
+     *    ring, tinted leading icon, two-tone value, trailing caret). */
+    variant: 'filled' | 'outlined' | 'filter';
     /** Semantic color */
-    color: 'default' | 'primary' | 'success' | 'error' | 'warning' | 'info';
+    color: 'default' | 'primary' | 'success' | 'error' | 'warning' | 'info' | 'pending' | 'progress' | 'review' | 'submitted';
     /** Text label (alternative to default slot) */
     label?: string;
     /** Icon name for the left icon (prop-based, uses co-icon — any Phosphor icon name) */
     iconLeft?: string;
     /** Icon name for the right icon (prop-based, uses co-icon — any Phosphor icon name) */
     iconRight?: string;
-    /** Icon weight applied to prop-based iconLeft / iconRight. */
+    /** Icon weight applied to prop-based iconLeft / iconRight / trailingIcon. */
     iconWeight: 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
-    /** Show dismiss/remove button and emit coRemove on click */
+    /** Muted two-tone value suffix rendered right after the label as
+     *  ": <valueLabel>" (e.g. label "Ordenar" + valueLabel "Reciente" →
+     *  "Ordenar: Reciente"). The suffix is coloured with --co-chip-value-color
+     *  (default gray-500). Omit for a plain chip. */
+    valueLabel?: string;
+    /** Trailing icon name (prop-based, uses co-icon — any Phosphor icon name),
+     *  e.g. 'caret-down'. In the `filter` variant it renders at 13px in gray-400;
+     *  in other variants it inherits the chip text colour. */
+    trailingIcon?: string;
+    /** Show dismiss/remove button and emit coRemove on click. Reflected so it
+     *  survives lazy hydration when set via a framework wrapper. */
     removable: boolean;
+    /** Show a leading colour dot (status/value colour). Reflected for hydration. */
+    dot: boolean;
+    /** Colour of the leading dot (hex or any CSS colour). Reflected for hydration. */
+    dotColor?: string;
     /** Make the chip clickable (emits coClick) */
     clickable: boolean;
     /** Disabled state */

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

@@ -27,6 +27,8 @@ export declare class CoColorPicker {
     helperText?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input): s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
     /** Field name for form submission. */
     name?: string;
     /**

package/dist/types/components/co-command-search/co-command-search.d.ts

@@ -1,10 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-export interface CommandItem {
-    label: string;
-    icon?: string;
-    value: string;
-    section?: string;
-}
+import { CommandItem } from './commandSearchGroup';
 /**
  * A command palette / search component (⌘K style).
  * Opens as an overlay with a search input and filterable list of items.
@@ -21,18 +16,56 @@ export declare class CoCommandSearch {
     items: string | CommandItem[];
     /** Empty state message when no results match */
     emptyMessage: string;
+    /** When true, the host supplies already-filtered, ordered items: disable
+     *  internal client filtering so fetch-as-you-type results pass through. */
+    async: boolean;
+    /** Show a loading indicator in the results area (async fetch in flight). */
+    loading: boolean;
+    /** Facet chips as JSON string: [{label:string, icon?:string}[]] */
+    chips: string;
+    /** Module tabs (mac-Spotlight style) as JSON: [{value,label,icon}]. Empty = no tabs row. */
+    tabs: string;
+    /** The active tab's value (the scope model key), or '' = no active tab. */
+    activeTab: string;
+    /** Show the "Más ▾" overflow tab. */
+    hasMore: boolean;
+    /** Label for the overflow tab. */
+    moreLabel: string;
+    /** Favorites / shortcuts grid (mac-Spotlight app grid) as JSON: [{value,label,icon,color}].
+     *  Shown as a grid at the top of the results, only while the query is empty. */
+    favorites: string;
     private query;
     private activeIndex;
     coSelect: EventEmitter<string>;
     coClose: EventEmitter<void>;
+    coQueryChange: EventEmitter<string>;
+    /** Emitted when an item with keepOpen=true is selected. Detail = item.value (scope model key). */
+    coScopeChange: EventEmitter<string>;
+    /** Emitted when Backspace is pressed with an empty query, or when the scope chip ✕ is clicked.
+     *  Detail = current query string (always '' at emit time). Host decides: pop scope or remove last facet. */
+    coBackspaceEmpty: EventEmitter<string>;
+    /**
+     * Emitted when the user clicks ✕ on a facet chip.
+     * detail = chip index (number).
+     */
+    coChipRemove: EventEmitter<number>;
+    /** Emitted when a module tab is clicked. detail = tab value; '' when the active tab is re-clicked (deselect). */
+    coTabSelect: EventEmitter<string>;
+    /** Emitted when the "Más ▾" overflow tab is clicked. */
+    coMoreTabs: EventEmitter<void>;
     private inputEl?;
     private get parsedItems();
     private get filteredItems();
+    private get parsedChips();
+    private get parsedTabs();
+    private get parsedFavorites();
     /** Item label with the matched substring wrapped for highlighting. */
     private renderLabel;
+    onActiveTabChange(newVal: string): void;
     onOpenChange(newVal: boolean): void;
     private handleInput;
     private handleKeyDown;
+    /** Two-stage commit: keepOpen items emit coScopeChange only; all others emit coSelect + close. */
     private selectItem;
     private close;
     private handleOverlayClick;

package/dist/types/components/co-command-search/commandSearchGroup.d.ts

@@ -0,0 +1,20 @@
+export interface CommandItem {
+    label: string;
+    value: string;
+    icon?: string;
+    subtitle?: string;
+    section?: string;
+    /** When true, selectItem emits coScopeChange only (no coSelect, no close). Two-stage commit. */
+    keepOpen?: boolean;
+}
+export type RenderRow = {
+    kind: 'header';
+    label: string;
+} | {
+    kind: 'item';
+    item: CommandItem;
+    index: number;
+};
+/** Flatten an ordered CommandItem[] into render rows, inserting a header
+ *  whenever the section changes. `index` counts items only (drives activeIndex). */
+export declare function groupItems(items: CommandItem[]): RenderRow[];

package/dist/types/components/co-command-search/commandSearchLogic.d.ts

@@ -0,0 +1,17 @@
+import { CommandItem } from './commandSearchGroup.js';
+/**
+ * Pure: should the component keep open and emit coScopeChange
+ * instead of the default coSelect+close?
+ */
+export declare function shouldKeepOpen(item: CommandItem): boolean;
+/**
+ * Pure: should coBackspaceEmpty fire?
+ * True when the user presses Backspace with an empty query.
+ */
+export declare function isEmptyBackspace(key: string, query: string): boolean;
+/**
+ * Pure: client-side item filtering.
+ * Mirrors the filteredItems getter logic from co-command-search.tsx.
+ * When async=true all items pass through (host already filtered them).
+ */
+export declare function applyClientFilter(items: CommandItem[], query: string, async: boolean): CommandItem[];