@prolibu-suite/cobalt-core 0.10.4 → 0.11.1

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

@@ -1,29 +1,188 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Control deslizante para elegir un número dentro de un rango, horizontal o
+ * vertical (volumen: el máximo arriba). `coInput` es la vista previa mientras se
+ * arrastra y `coChange` confirma una vez al terminar el gesto. Wrapper Vue:
+ * `CoSlider` de `@prolibu-suite/cobalt-vue`.
+ */
 export declare class CoSlider {
+    /** Etiqueta visible; también da el nombre accesible si no hay `ariaLabelText`. */
     label?: string;
+    /**
+     * Nombre accesible del control, SIN dibujar etiqueta. `label` hace las dos
+     * cosas a la vez (rotula y nombra), así que un slider sin etiqueta visible
+     * —los dos del panel de Multimedia del editor, y cualquier control con el
+     * rótulo afuera— se quedaba llamándose `"Slider"`: literal, en inglés y para
+     * todos los idiomas.
+     *
+     * Mismo nombre de prop que `co-fab`, `co-button` y `co-action-bar`, y la
+     * misma precedencia que `co-fab` y `co-action-bar` (`ariaLabelText || label`;
+     * `co-button` no tiene `label` que nombre: cae al texto de su contenido).
+     * El fallback final es propio de cada componente; acá, `"Slider"`. Aditiva —
+     * sin ella el markup y el `aria-label` son byte-idénticos a los de siempre.
+     *
+     * La resolución es por `||` sobre el valor RECIBIDO y no por un default de
+     * clase: un wrapper (`@lit/react`, el `defineContainer` de Vue) que pasa la
+     * prop sin valor manda `undefined` y pisa cualquier default sembrado por
+     * Stencil, así que `undefined` y `''` tienen que caer del lado de SIEMPRE —
+     * el mismo criterio que el `=== 'vertical'` de `isVertical`.
+     */
+    ariaLabelText?: string;
+    /** Texto secundario junto a la etiqueta (p. ej. la unidad). */
     secondaryLabel?: string;
+    /** Texto de ayuda o de error bajo el control. */
     helperText?: string;
+    /** Estado de validación: colorea el `helperText`. */
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
+    /** Valor actual; el componente lo actualiza al arrastrar o con el teclado. */
     value: number;
+    /** Mínimo del rango (default 0). */
     min: number;
+    /** Máximo del rango (default 100). */
     max: number;
+    /** Paso entre valores (default 1); también el paso de las flechas. */
     step: number;
+    /** Deshabilita el control. */
     disabled: boolean;
     /** Show current value label */
     showValue: boolean;
     /** Show min/max marks */
     showMarks: boolean;
+    /**
+     * Eje del control. `horizontal` (default) es el slider de siempre: mismo
+     * markup, mismo CSS, mismos eventos — la variante es ADITIVA y ningún
+     * consumidor actual (prolibu-front-v2) cambia de comportamiento.
+     *
+     * `vertical` INVIERTE el eje como manda la convención de un control de
+     * volumen: arriba es MÁS. El relleno crece desde abajo, el thumb se posiciona
+     * por `bottom`, y el largo del riel se ajusta con la variable
+     * `--co-slider-vertical-length` (default 120px).
+     *
+     * NO lleva `reflect`: reflejar una prop de string con default escribiría
+     * `orientation="horizontal"` en el host de TODOS los consumidores actuales, y
+     * eso ya sería cambiarles el markup. El estilo cuelga de la clase interna
+     * `.co-slider--vertical`, que es nuestra.
+     */
+    orientation: 'horizontal' | 'vertical';
     dragging: boolean;
     el: HTMLElement;
+    /** Confirma el valor: una vez al terminar el gesto (si hubo algún `coInput`) y en cada paso de teclado. `detail` = número. */
     coChange: EventEmitter<number>;
+    /** Vista previa mientras se arrastra, solo cuando el valor cambia. `detail` = número. */
     coInput: EventEmitter<number>;
     private trackEl?;
+    /** Puntero dueño del gesto en curso: un segundo dedo no lo secuestra. */
+    private dragPointerId?;
+    /** ¿Algún `coInput` real durante el gesto? Sin cambio no hay `coChange` de cierre. */
+    private changedInGesture;
+    /**
+     * `=== 'vertical'` y no `!== 'horizontal'`: con `@stencil/vitest` las `@Prop`
+     * omitidas en `h()` llegan `undefined` (no se siembra el default), y un valor
+     * ausente tiene que caer del lado de SIEMPRE, que es el horizontal.
+     */
+    private get isVertical();
     private get percentage();
     private get statusIcon();
     private clamp;
     private snap;
-    private valueFromEvent;
+    /**
+     * Valor bajo el puntero. En horizontal el eje va de `left` a `right`; en
+     * vertical va de ABAJO hacia arriba (`bottom - clientY`), así que acercarse
+     * al borde superior sube el valor.
+     *
+     * El guard de tamaño evita el `NaN` que salía de dividir por un riel de 0px
+     * (track sin medir todavía, o dentro de un contenedor colapsado).
+     */
+    private valueFromPointer;
+    /**
+     * Aplica el valor y emite `coInput` SOLO si cambió — el contrato de la casa
+     * (gemelo de `commitInput` en co-color-slider / co-color-area).
+     *
+     * Que `coInput` sea condicional es lo que cierra el ciclo de vida del
+     * consumidor: en el editor `coInput` ABRE una foto de "antes" y `coChange` la
+     * LIBERA (`fill/gestureHistory.ts`). Con las dos condiciones atadas al mismo
+     * `changedInGesture`, vale la invariante **"todo gesto que emitió `coInput`
+     * termina con exactamente un `coChange`"**: si el valor nunca se movió no se
+     * abre ninguna foto, y si se movió —aunque vuelva al de partida— hay cierre.
+     * Emitir `coInput` en cada paso (como antes) y `coChange` solo si el valor
+     * FINAL difería dejaba fotos colgadas en la ida y vuelta 50→80→50.
+     */
+    private commitInput;
+    /** `==`: en jsdom un MouseEvent sintético trae `pointerId` undefined y debe seguir pasando. */
+    private isGesturePointer;
     private handlePointerDown;
+    private handleGesturePointerMove;
+    /**
+     * Fin del gesto — `pointerup` y también `pointercancel`, igual que el
+     * `handlePointerEnd` de co-color-slider / co-color-area: cancelar TERMINA el
+     * gesto y CONFIRMA lo alcanzado, no revierte.
+     *
+     * (Una versión anterior de esta rama revertía al valor previo con un `coInput`
+     * de rollback, copiando el arrastre de `co-modal movable`. Se descartó: el
+     * modal mueve una posición cosmética que no tiene canal de commit, mientras
+     * que acá el valor ES estado del host. Los dos sliders del propio design
+     * system confirman al cancelar, un `input type="range"` nativo también
+     * conserva el valor en `pointercancel`, y revertir obligaba al host a saber
+     * absorber un `coInput` de vuelta atrás — contrato de más, distinto al de los
+     * hermanos.)
+     */
+    private handleGestureEnd;
+    /** Perder el foco de la ventana (alt-tab, un iframe que se lo lleva) cierra
+     *  el gesto igual que un `pointercancel`: sin esto, un puntero que nunca
+     *  suelta su `pointerup` deja el arrastre vivo. */
+    private handleWindowBlur;
+    private bindGesture;
+    private unbindGesture;
+    /**
+     * Cierra el gesto y devuelve si hubo algún `coInput` — el ÚNICO lugar donde
+     * se apaga `changedInGesture`, para que todos los finales (pointerup,
+     * pointercancel, blur, desconexión) compartan la misma contabilidad.
+     *
+     * Que la bandera se desarme acá es lo que impide un `coChange` de más: antes
+     * solo se ponía en `false` al ARRANCAR el gesto siguiente, así que una vez
+     * movido el valor quedaba armada para siempre y `disconnectedCallback`
+     * —que cierra el gesto con su `coChange`— reemitía un commit con el valor ya
+     * escrito CADA vez que el elemento se desmontaba. En el editor eso marcaba el
+     * documento como "modificado" al cerrar el popover sin que hubiera edición;
+     * el evento de más le llega a cualquier consumidor.
+     */
+    private endGesture;
+    /**
+     * Desmontarse en pleno gesto tiene que dejar el componente como si nunca
+     * hubiera empezado: `endGesture()` y no solo `unbindGesture()`. Con `dragging`
+     * en `true`, una instancia que se desconecta y se vuelve a conectar (reorden
+     * de una lista keyed, un `Teleport`) quedaba sin listeners Y rechazando todo
+     * `pointerdown` por el guard de arriba: slider muerto al puntero para siempre.
+     *
+     * Y CIERRA el gesto con su `coChange`, como cualquier otro final: era el único
+     * camino donde la invariante ("todo gesto que emitió `coInput` termina con
+     * exactamente un `coChange`") no valía. Sin el cierre, un host que se recrea
+     * el subárbol con el thumb agarrado deja abierta la foto de "antes" del
+     * historial y la edición siguiente del mismo nodo se registra contra ella.
+     *
+     * El `dispatchEvent` sobre un nodo ya desconectado llega igual a los listeners
+     * puestos sobre el propio elemento, que es como enganchan `@lit/react` y el
+     * `defineContainer` de Vue.
+     */
+    disconnectedCallback(): void;
     private handleInputChange;
+    /**
+     * Flechas de la variante VERTICAL: las resuelve el componente en vez de
+     * delegarlas al range nativo, y solo ahí — en horizontal este handler NO se
+     * engancha (ver `render`), así que el camino de siempre no cambia en nada.
+     *
+     * Por qué: la orientación vertical del input se consigue con
+     * `writing-mode: vertical-rl` + `direction: rtl` (ver co-slider.css). Un motor
+     * que ignore `writing-mode` en form controls pero sí honre `direction`
+     * (Safari 17.0–17.3, Firefox < 129) deja ←/→ INVERTIDOS. Manejadas acá, las
+     * cuatro flechas siguen el eje en cualquier motor — arriba/derecha suben,
+     * abajo/izquierda bajan, de a `step` — y el contrato queda testeable (jsdom no
+     * implementa el teclado del range nativo).
+     *
+     * PageUp/PageDown/Home/End siguen siendo del nativo. Emite `coChange` y no
+     * `coInput`, exactamente como el paso de teclado del horizontal
+     * (`handleInputChange`): un paso discreto es un commit, no un preview.
+     */
+    private handleVerticalKeyDown;
     render(): any;
 }

package/dist/types/components/co-swatch-grid/co-swatch-grid.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Grilla de muestras de color ("Colores recientes" del popover de relleno).
+ * Listbox de una sola selección: click (o Enter/Espacio) emite `coSelect` con
+ * el color; las flechas solo mueven el foco (roving tabindex).
+ *
+ * Los colores claros (luminancia WCAG > 0,85) reciben un borde automático
+ * para no fundirse con el fondo del panel.
+ * Wrapper Vue: `CoSwatchGrid` de `@prolibu-suite/cobalt-vue`.
+ */
+export declare class CoSwatchGrid {
+    el: HTMLElement;
+    /** Colores a mostrar (hex/rgba), en orden de lectura. */
+    colors: string[];
+    /** Color seleccionado (anillo `accent`); se compara sin distinguir mayúsculas. */
+    value?: string;
+    /** Columnas de la grilla. */
+    columns: number;
+    /** Lado de cada swatch en px. */
+    swatchSize: number;
+    /** Separación entre swatches en px. */
+    gap: number;
+    /** Radio de cada swatch en px. */
+    radius: number;
+    /** aria-label del listbox. Vacío = el del `locale`. */
+    label?: string;
+    /** Locale de los strings integrados (es/en/pt). */
+    locale?: string;
+    /** Color elegido (el string tal cual vino en `colors`). */
+    coSelect: EventEmitter<string>;
+    private swatchEls;
+    private static normalize;
+    private get colorList();
+    private get columnCount();
+    private selectedIndex;
+    private handleKeyDown;
+    render(): any;
+}

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

@@ -1,4 +1,13 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Interruptor on/off para activar o desactivar una opción al instante, con
+ * etiqueta y texto secundario. Wrapper Vue: `CoSwitch` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part track - Riel del interruptor.
+ * @part thumb - Círculo que se desplaza.
+ * @part label - Etiqueta.
+ * @part secondary-label - Texto secundario bajo la etiqueta.
+ */
 export declare class CoSwitch {
     /** Whether the switch is on */
     checked: boolean;

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

@@ -1,4 +1,12 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Pestaña individual; va dentro de un `co-tab-group`, que le propaga `variant`,
+ * `size` y `fullWidth` y marca `selected` según su `value`. Wrapper Vue: `CoTab`
+ * de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part tab - El botón de la pestaña.
+ * @part badge - Contador junto al texto (`badge`).
+ */
 export declare class CoTab {
     /** Tab label */
     label: string;
@@ -6,8 +14,10 @@ export declare class CoTab {
     value: string;
     /** Whether this tab is active/selected */
     selected: boolean;
-    /** Size */
-    size: 'large' | 'small';
+    /** Tamaño: `large`/`small` (default) son los de las variantes pill y underline;
+     *  `s` (28px) y `xs` (26px) solo tienen estilo propio en `variant="segmented"`.
+     *  Dentro de un `co-tab-group` con `size`, el grupo lo fija. */
+    size: 'large' | 'small' | 's' | 'xs';
     /** Visual variant: filled pill (default), underline tab, or segmented-control pill */
     variant: 'pill' | 'underline' | 'segmented';
     /** Optional count/badge pill rendered after the label */
@@ -18,6 +28,14 @@ export declare class CoTab {
     iconRight?: string;
     /** Disabled state */
     disabled: boolean;
+    /** Estira el botón interno (`part="tab"`) al 100% del host y centra su
+        contenido. Lo setea `co-tab-group` con `full-width` (se propaga a los
+        hijos igual que `size`, ver `syncTabs()`: el grupo sin `fullWidth` nunca
+        pisa uno puesto a mano acá): el grupo ya estiraba el host con
+        `::slotted(co-tab) { flex: 1 }`, pero el `.co-tab` de adentro seguía al
+        ancho del contenido. Reflejado para que `:host([full-width])` lo vea
+        desde el CSS. Sin él, nada cambia. */
+    fullWidth: boolean;
     /** Emitted when tab is clicked */
     coTabSelect: EventEmitter<string>;
     private handleClick;

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

@@ -1,21 +1,67 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Grupo de pestañas (`co-tab`) que controla cuál está activa: `value` marca la
+ * pestaña, al elegir otra se actualiza y emite `coTabChange`. Propaga `variant`,
+ * `size` y `fullWidth` a sus pestañas y, si desbordan, lleva la activa a la
+ * vista. Wrapper Vue: `CoTabGroup` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @slot - Los `co-tab` del grupo.
+ * @part tab-group - La pista que contiene las pestañas.
+ */
 export declare class CoTabGroup {
     el: HTMLElement;
     /** Currently selected tab value */
     value?: string;
     /** Visual variant, propagated to slotted co-tab children */
     variant: 'pill' | 'underline' | 'segmented';
+    /** Track/tab size — solo tiene chrome propio en `variant="segmented"`
+        ('s' = 28px, 'xs' = 26px, ver co-tab-group.css / co-tab.css). Se propaga
+        a los `co-tab` hijos igual que `variant` (mismo mecanismo, `syncTabs()`),
+        pero solo cuando está seteado: un grupo sin `size` nunca pisa un `size`
+        puesto a mano en un `co-tab` hijo. */
+    size?: 's' | 'xs';
+    /** Estira el host y el track al 100% del contenedor; cada `co-tab` hijo
+        reparte el ancho por igual (`::slotted(co-tab) { flex: 1 }`) y, como se
+        propaga a los hijos igual que `size` (`syncTabs()`), cada `co-tab`
+        estira además su `part="tab"` al 100% del host (`:host([full-width])
+        .co-tab` en co-tab.css). Mismo contrato que `size`: un grupo sin
+        `fullWidth` nunca pisa un `fullWidth` puesto a mano en un hijo, y al
+        apagarlo baja solo a los hijos que él mismo subió. */
+    fullWidth: boolean;
+    /** Hijos a los que ESTE grupo les subió `fullWidth` — al apagar `fullWidth`
+        en el grupo se baja solo a estos, nunca a uno puesto a mano (M1). */
+    private raisedFullWidth;
     /** Emitted when the active tab changes */
     coTabChange: EventEmitter<string>;
     onTabSelect(e: CustomEvent<string>): void;
     watchValue(): void;
     watchVariant(): void;
+    watchSize(): void;
+    watchFullWidth(): void;
     componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /** Las pestañas cambian de ancho DESPUÉS del primer ajuste (llega la fuente,
+        contadores "Notas (2)"): medido en la suite, la activa quedaba 8 px cortada.
+        Al cambiar el tamaño de alguna se vuelve a mostrar la activa. No reacciona
+        al scroll del usuario, sólo a cambios de tamaño. */
+    private tabsObserver?;
+    private observeTabSizes;
     /** Slotted tabs can mount AFTER the group (async v-for data): re-propagate
         variant/selection whenever the slot content changes, or late tabs render
         with the default pill variant. */
     private onSlotChange;
+    /** Lleva la pestaña activa a la vista dentro del track (sólo scroll horizontal
+        del track: la página no se mueve). Sin esto, abrir con una pestaña del final
+        activa (deep-link `?tab=`) la dejaba fuera de la tira. En rAF: al cargar y
+        con tabs async todavía no hay layout. */
+    private revealSelected;
     private syncTabs;
+    /** Propaga `fullWidth` con el contrato de `size`: con el grupo en true, sube
+        al hijo (y lo anota); con el grupo en false, baja SOLO a los que subió
+        este grupo — un `fullWidth` puesto a mano en el hijo queda intacto. Sin
+        `fullWidth` en el grupo y sin hijos anotados, no toca nada: el DOM del
+        hijo queda como siempre (aditivo). */
+    private syncFullWidth;
     /** Wheel → horizontal scroll cuando el track desborda (los tabs clipean con
         `overflow-x`, ver CSS): la rueda vertical del mouse scrollea el strip.
         Solo consume el evento si realmente puede desplazarse en esa dirección —

package/dist/types/components/co-tab-group/revealTab.d.ts

@@ -0,0 +1,29 @@
+interface Edges {
+    left: number;
+    right: number;
+}
+/**
+ * `scrollLeft` del track para que la pestaña quede ENTERA a la vista (con `pad`
+ * de aire). Rects en coordenadas de viewport (getBoundingClientRect). Si ya se
+ * ve, devuelve el mismo `scrollLeft`: no hay salto.
+ */
+export declare function revealScrollLeft(scrollLeft: number, track: Edges, tab: Edges, pad?: number): number;
+interface TrackBox {
+    offsetWidth: number;
+    clientWidth: number;
+    clientLeft: number;
+}
+/**
+ * Bordes de la pestaña y del área visible del track en px CSS relativos al
+ * borde interno del track (el mismo espacio que `scrollLeft`). Los rects de
+ * getBoundingClientRect salen ESCALADOS si un ancestro tiene transform (el
+ * drawer entra con escala): se dividen por la escala visual del track.
+ */
+export declare function tabEdgesInTrack(trackRect: {
+    left: number;
+    width: number;
+}, tabRect: Edges, box: TrackBox): {
+    track: Edges;
+    tab: Edges;
+};
+export {};

package/dist/types/components/co-tags-field/co-tags-field.d.ts

@@ -19,17 +19,26 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * @part input - The native text input
  * @part clear - The clear-all button
  * @part helper - The helper/error text row
+ *
+ * Wrapper Vue: `CoTagsField` de `@prolibu-suite/cobalt-vue`.
  */
 export declare class CoTagsField {
     el: HTMLElement;
     /** Committed value as a JSON array of strings (or an actual `string[]`). */
     value: string[] | string;
+    /** Etiqueta del campo. */
     label?: string;
+    /** Placeholder del input para escribir un tag nuevo. */
     placeholder: string;
+    /** Atributo `name` del input nativo. */
     name?: string;
+    /** Campo obligatorio: marca la etiqueta con el indicador de requerido. */
     required: boolean;
+    /** Deshabilita el campo. */
     disabled: boolean;
+    /** Solo lectura: muestra los tags sin permitir agregar ni quitar. */
     readonly: boolean;
+    /** Botón × que quita todos los tags (default `true`); emite `coClear`. */
     clearable: boolean;
     /** Maximum number of tags allowed (no cap when undefined). */
     maxTags?: number;
@@ -51,7 +60,9 @@ export declare class CoTagsField {
     coInput: EventEmitter<string>;
     /** Emitted when the clear-all button is clicked. */
     coClear: EventEmitter<void>;
+    /** El input ganó el foco. */
     coFocus: EventEmitter<void>;
+    /** El input perdió el foco. */
     coBlur: EventEmitter<void>;
     /** Raw text in the inline input. */
     draft: string;

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

@@ -0,0 +1,45 @@
+/**
+ * co-tile — tarjeta de 96×80 con ícono + etiqueta, usada en la grilla de
+ * "Plantillas de página" del editor. El host (el propio elemento
+ * personalizado) es el nodo focuseable/arrastrable: no declara eventos
+ * propios (`click`/`dragstart`/`pointerdown`) porque el consumidor
+ * (dnd-kit) los escucha directamente sobre el host — el componente solo
+ * pone `role`/`tabindex`/`aria-disabled` para que ese nodo sea accesible
+ * por teclado, y traduce Enter/Space a un `click` nativo sobre el host
+ * (semántica de `<button>`: Enter en keydown; Space frena el scroll en
+ * keydown y activa en keyup) para que el mismo listener del consumidor
+ * sirva con teclado.
+ *
+ * @slot icon - Reemplaza el `co-icon` por defecto (renderizado a partir de
+ *              `icon`/`iconSize`) por contenido propio del consumidor.
+ *
+ * @part tile - La tarjeta.
+ * @part label - La etiqueta bajo el ícono.
+ *
+ * Wrapper Vue: `CoTile` de `@prolibu-suite/cobalt-vue`.
+ */
+export declare class CoTile {
+    /** Etiqueta visible debajo del ícono. Soporta `\n` (se renderiza en dos líneas). */
+    label: string;
+    /** Nombre del ícono Phosphor (e.g. "file", "calculator"). */
+    icon?: string;
+    /** Tamaño del ícono por defecto, en px. */
+    iconSize: number;
+    /** Deshabilitada: pierde el `tabindex` y queda `aria-disabled`, pero conserva `role="button"`. */
+    disabled: boolean;
+    el: HTMLElement;
+    /** Space quedó presionada SOBRE esta tile (el keyup solo activa si el
+     *  keydown fue acá — un <button> nativo tampoco dispara por un keyup
+     *  suelto). */
+    private spaceArmed;
+    /** Solo eventos que nacen en el host (o en su shadow, retargeteados al
+     *  host): un control proyectado en el slot `icon` maneja sus propias
+     *  teclas y no debe activar la tile por rebote. */
+    private ownsKeyEvent;
+    private handleKeyDown;
+    private handleKeyUp;
+    /** Perder el foco entre el keydown y el keyup de Space desarma (un
+     *  <button> nativo tampoco dispara si el keyup cae en otro lado). */
+    private handleBlur;
+    render(): any;
+}

package/dist/types/components/co-time-field/co-time-field.d.ts

@@ -10,6 +10,8 @@ type Segment = 'hour' | 'minute' | 'period';
  * (co-date-time-picker: coInput→draft, coCommit→commit+close).
  * `coEscape` = anuncio de intención; el picker NO lo wirea — ver
  * co-date-time-picker.tsx (Escape lo posee su root handler).
+ *
+ * Wrapper Vue: `CoTimeField` de `@prolibu-suite/cobalt-vue`.
  */
 export declare class CoTimeField {
     el: HTMLElement;
@@ -17,7 +19,9 @@ export declare class CoTimeField {
     value: number | null;
     /** Reloj de 12 h. `false` = 00–23 sin segmento de período. */
     hour12: boolean;
+    /** Locale BCP-47: textos del período (a. m./p. m.) y nombres accesibles de los segmentos. */
     locale: string;
+    /** Deshabilita el campo. */
     disabled: boolean;
     /** Paso de PageUp/PageDown sobre el minuto. */
     pageStep: number;
@@ -41,6 +45,7 @@ export declare class CoTimeField {
     private hourEl?;
     componentWillLoad(): void;
     syncFromValue(v: number | null): void;
+    /** Enfoca el segmento de la hora. */
     focusInput(): Promise<void>;
     private minutesOfDay;
     private get isPm();

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

@@ -2,6 +2,11 @@ import { EventEmitter } from '../../stencil-public-runtime';
 export type CoToastVariant = 'success' | 'error' | 'warning' | 'info' | 'neutral';
 export type CoToastActionsLayout = 'inline' | 'stacked';
 /**
+ * Notificación breve con mensaje, descripción opcional, ícono, acciones y ✕,
+ * con variantes semánticas y barra de progreso opcional. Es solo la tarjeta:
+ * mostrarla, apilarla y ocultarla es del host. Wrapper Vue: `CoToast` de
+ * `@prolibu-suite/cobalt-vue`.
+ *
  * @slot action - Action area (buttons, icon buttons)
  *
  * Figma variants (Tipos) are layout choices:
@@ -11,6 +16,10 @@ export type CoToastActionsLayout = 'inline' | 'stacked';
  * - Tipo=04 → message + inline icon action + dismiss
  *
  * Semantic `variant` adds a colored left accent + tinted icon + default icon when none provided.
+ *
+ * @part toast - Tarjeta del toast.
+ * @part track - Riel de la barra de progreso (`progress`).
+ * @part fill - Relleno de la barra de progreso.
  */
 export declare class CoToast {
     /**

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

@@ -1,22 +1,65 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * co-toggle-button — pastilla de un `co-toggle-button-group`.
+ * Wrapper Vue: `CoToggleButton` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part button - El `<button>` interno. El hook para lo que el CSS deja
+ *                hardcodeado y no tiene prop, empezando por su
+ *                `justify-content: center`: `::part(button) { justify-content:
+ *                flex-start }` alinea el contenido a la izquierda sin tener que
+ *                mover el texto a un slot.
+ * @slot leading - Contenido propio antes del label (logos a color, banderas):
+ *                 lo espacia el mismo `gap` que a `iconLeft`.
+ */
 export declare class CoToggleButton {
+    /** Activado (reflejado). El click lo invierte; dentro de un `co-toggle-button-group` lo coordina el grupo. */
     selected: boolean;
+    /** Valor que identifica al botón dentro de su grupo y que viaja en `coToggle`. */
     value: string;
+    /** Texto del botón. */
     label?: string;
+    /** Ícono Phosphor antes del texto. */
     iconLeft?: string;
+    /** Ícono Phosphor después del texto. */
     iconRight?: string;
+    /** Talla del botón. Si no se indica (ni atributo ni propiedad) y el botón
+     *  está dentro de un `co-toggle-button-group` con `variant="soft"` (cualquier
+     *  talla) o `variant="track"` + `size="xs"`, adopta la talla del grupo al
+     *  montarse — la lee el propio botón en `componentWillLoad`, ver
+     *  `adoptGroupSize()`. Un `size` propio siempre manda. En cualquier otra
+     *  combinación (`connected`, `track` con `l|m|s`, o una talla fuera de
+     *  `l|m|s|xs`) el grupo no influye, exactamente como antes. La talla se
+     *  adopta UNA vez, al montar: cambiar después el `size` del grupo no
+     *  re-talla a los botones ya montados (el editor lo fija estáticamente). */
     size: 'l' | 'm' | 's' | 'xs';
+    /** Deshabilita el botón. */
     disabled: boolean;
     /** Visual variant. 'track' renders the button as a detached rounded pill for a
-     *  sunken toggle-button-group track. Normally set by the parent group. */
-    variant: 'connected' | 'track';
+     *  sunken toggle-button-group track. 'soft' renders it as a separated gray-100
+     *  chip whose selected state uses the celeste-100/primary-azul accent pair.
+     *  Normally set by the parent group. */
+    variant: 'connected' | 'track' | 'soft';
     /** When set, the leading/trailing icon renders at this weight while the button
      *  is selected (e.g. 'fill' for the active segment of a track toggle). */
     selectedIconWeight?: 'regular' | 'fill';
+    el: HTMLElement;
+    /** Click en el botón: `{ value, selected }` con el estado nuevo. */
     coToggle: EventEmitter<{
         value: string;
         selected: boolean;
     }>;
+    componentWillLoad(): void;
+    /** Adopta la talla del grupo contenedor en las combinaciones nuevas de la
+     *  Fase 2 (`soft`, o `track` + `xs`) SOLO si este botón no trae `size`
+     *  propio. Vive en el hijo y corre ANTES del primer render a propósito:
+     *  `size` es `reflect: true`, así que en el primer render Stencil escribe el
+     *  default `m` como atributo del host — y ese render ocurre antes del
+     *  `componentDidLoad` del grupo. Propagar desde el grupo (versión anterior,
+     *  chequeaba `hasAttribute('size')` en el hijo) nunca actuaba en el browser:
+     *  a esa altura el atributo ya estaba y no se puede distinguir un `m`
+     *  explícito de uno reflejado. Los specs en jsdom no lo detectaban porque
+     *  `@stencil/vitest` no siembra el default de un class-field `@Prop`. */
+    private adoptGroupSize;
     private handleClick;
     render(): any;
 }

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

@@ -1,18 +1,44 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Grupo de `co-toggle-button` que coordina la selección: única (default) o
+ * `multiple`. `variant` elige el estilo (`connected`, `track`, `soft`) y se
+ * propaga a los botones. Wrapper Vue: `CoToggleButtonGroup` de
+ * `@prolibu-suite/cobalt-vue`.
+ */
 export declare class CoToggleButtonGroup {
     /** Current selected value(s). Single string or JSON array for multiple. */
     value: string | string[];
+    /** Selección múltiple: `value` y `coChange` llevan un array de valores. */
     multiple: boolean;
+    /** Talla del grupo. El grupo NO la empuja a sus hijos: cada `co-toggle-button`
+     *  sin `size` propio la LEE al montarse (`componentWillLoad`, antes de su
+     *  primer render) y la adopta SOLO en las combinaciones compactas del editor
+     *  — `variant="soft"` (cualquier talla) o `variant="track"` +
+     *  `size="xs"` — y nunca con un valor fuera de la unión del hijo (`l|m|s|xs`).
+     *  Fuera de eso los hijos la ignoran, como siempre: el host ya usa
+     *  `size="sm"` (fuera de la unión) y `size="s"` con la variante default, y
+     *  esos casos quedan intactos (aditivo). Por qué lo lee el hijo y no lo
+     *  empuja el grupo: `size` del hijo es `reflect: true` y su primer render —
+     *  que escribe el default `m` como atributo — ocurre ANTES del
+     *  `componentDidLoad` del grupo, así que el grupo ya no puede distinguir un
+     *  `m` explícito de uno reflejado. Consecuencia: se adopta una vez, al
+     *  montar; cambiar `size` del grupo después no re-talla a los hijos ya
+     *  montados (aquí solo actualiza la clase `--xs` de la pista). */
     size: 'l' | 'm' | 's' | 'xs';
+    /** Deshabilita todos los botones del grupo. */
     disabled: boolean;
+    /** Disposición de los botones: `row` (default) o `column`. */
     direction: 'row' | 'column';
     /** Stretch the group to fill its container; each button shares the width equally. */
     fullWidth: boolean;
     /** 'connected' (default) keeps the seamless dark-fill segmented control.
      *  'track' turns the group into a sunken gray track carrying detached rounded
-     *  pills (white + shadow when selected) — e.g. an icon-only view toggle. */
-    variant: 'connected' | 'track';
+     *  pills (white + shadow when selected) — e.g. an icon-only view toggle.
+     *  'soft' separates each button into its own gray-100 chip (gap between them);
+     *  the selected chip gets the celeste-100/primary-azul accent pair. */
+    variant: 'connected' | 'track' | 'soft';
     el: HTMLElement;
+    /** Cambió la selección (`value` ya está actualizado): el valor elegido, o el array en `multiple`. */
     coChange: EventEmitter<string | string[]>;
     private get selectedValues();
     syncChildren(): void;
@@ -22,6 +48,8 @@ export declare class CoToggleButtonGroup {
         value: string;
         selected: boolean;
     }>): void;
+    /** Sincroniza `selected` y `variant` en los hijos. `size` NO se toca acá a
+     *  propósito: lo adopta cada hijo al montarse (ver doc del @Prop `size`). */
     private updateChildStates;
     render(): any;
 }