@prolibu-suite/cobalt-core 0.10.4 → 0.11.1

package/dist/esm/{positioning-DFHRS9cJ.js → positioning-BtliEQAT.js}

@@ -10,9 +10,15 @@
  * Calculate top/left for a fixed-position panel relative to a trigger.
  */
 function computePosition(triggerRect, panelRect, options) {
+    var _a, _b;
     const { offset, flip } = options;
     const viewportH = window.innerHeight;
     const viewportW = window.innerWidth;
+    const shift = (_a = options.shift) !== null && _a !== void 0 ? _a : 0;
+    // Task C10 (Fase 2 Cobalt): con `anchor`, TODA la matemática (flip incluido)
+    // se hace contra el rect del anchor en vez del trigger. Sin `anchorRect`,
+    // `referenceRect === triggerRect` — cero cambio de comportamiento.
+    const referenceRect = (_b = options.anchorRect) !== null && _b !== void 0 ? _b : triggerRect;
     let placement = options.placement;
     // Auto-flip if needed
     if (flip) {
@@ -21,29 +27,29 @@ function computePosition(triggerRect, panelRect, options) {
         const isRight = placement.startsWith('right');
         const isLeft = placement.startsWith('left');
         if (isBottom) {
-            const spaceBelow = viewportH - triggerRect.bottom - offset;
-            const spaceAbove = triggerRect.top - offset;
+            const spaceBelow = viewportH - referenceRect.bottom - offset;
+            const spaceAbove = referenceRect.top - offset;
             if (spaceBelow < panelRect.height && spaceAbove > spaceBelow) {
                 placement = placement.replace('bottom', 'top');
             }
         }
         else if (isTop) {
-            const spaceAbove = triggerRect.top - offset;
-            const spaceBelow = viewportH - triggerRect.bottom - offset;
+            const spaceAbove = referenceRect.top - offset;
+            const spaceBelow = viewportH - referenceRect.bottom - offset;
             if (spaceAbove < panelRect.height && spaceBelow > spaceAbove) {
                 placement = placement.replace('top', 'bottom');
             }
         }
         else if (isRight) {
-            const spaceRight = viewportW - triggerRect.right - offset;
-            const spaceLeft = triggerRect.left - offset;
+            const spaceRight = viewportW - referenceRect.right - offset;
+            const spaceLeft = referenceRect.left - offset;
             if (spaceRight < panelRect.width && spaceLeft > spaceRight) {
                 placement = placement.replace('right', 'left');
             }
         }
         else if (isLeft) {
-            const spaceLeft = triggerRect.left - offset;
-            const spaceRight = viewportW - triggerRect.right - offset;
+            const spaceLeft = referenceRect.left - offset;
+            const spaceRight = viewportW - referenceRect.right - offset;
             if (spaceLeft < panelRect.width && spaceRight > spaceLeft) {
                 placement = placement.replace('left', 'right');
             }
@@ -58,29 +64,33 @@ function computePosition(triggerRect, panelRect, options) {
     const isHorizontal = isRight || isLeft;
     if (isHorizontal) {
         if (isRight)
-            left = triggerRect.right + offset;
+            left = referenceRect.right + offset;
         else
-            left = triggerRect.left - panelRect.width - offset;
+            left = referenceRect.left - panelRect.width - offset;
         const align = placement.split('-')[1] || 'center';
         if (align === 'start')
-            top = triggerRect.top;
+            top = referenceRect.top;
         else if (align === 'end')
-            top = triggerRect.bottom - panelRect.height;
+            top = referenceRect.bottom - panelRect.height;
         else
-            top = triggerRect.top + (triggerRect.height - panelRect.height) / 2;
+            top = referenceRect.top + (referenceRect.height - panelRect.height) / 2;
+        // Eje cruzado de un placement horizontal (left*/right*) es vertical.
+        top += shift;
     }
     else {
         if (isTop)
-            top = triggerRect.top - panelRect.height - offset;
+            top = referenceRect.top - panelRect.height - offset;
         else
-            top = triggerRect.bottom + offset;
+            top = referenceRect.bottom + offset;
         const align = placement.split('-')[1] || 'center';
         if (align === 'start')
-            left = triggerRect.left;
+            left = referenceRect.left;
         else if (align === 'end')
-            left = triggerRect.right - panelRect.width;
+            left = referenceRect.right - panelRect.width;
         else
-            left = triggerRect.left + (triggerRect.width - panelRect.width) / 2;
+            left = referenceRect.left + (referenceRect.width - panelRect.width) / 2;
+        // Eje cruzado de un placement vertical (top*/bottom*) es horizontal.
+        left += shift;
     }
     // Clamp to viewport edges (4px margin)
     if (left < 4)
@@ -195,5 +205,21 @@ function findScrollParents(start) {
     }
     return out;
 }
+/**
+ * ¿El ancla (trigger) se ve todavía? Tiene que tener caja y cortar el viewport Y
+ * cada uno de sus scrollers (`clipRects`, del más cercano al más lejano — lo que
+ * devuelve `findScrollParents`, medido). Basta con que UNO la recorte entera para
+ * que no se vea: el kebab de una card que el scroll de su columna sacó por arriba
+ * sigue dentro del viewport, pero ya no es visible.
+ *
+ * Asomada en un borde cuenta como visible: el panel todavía tiene de qué colgar.
+ */
+function isAnchorVisible(anchor, clipRects) {
+    if (!anchor.width && !anchor.height)
+        return false;
+    const viewport = { top: 0, left: 0, bottom: window.innerHeight, right: window.innerWidth };
+    return [viewport, ...clipRects].every((clip) => anchor.bottom > clip.top && anchor.top < clip.bottom
+        && anchor.right > clip.left && anchor.left < clip.right);
+}
 
-export { computePosition as c, findScrollParents as f, getOffsetAncestor as g };
+export { computePosition as c, findScrollParents as f, getOffsetAncestor as g, isAnchorVisible as i };

package/dist/esm/{requiredMark-BCJUuZvC.js → requiredMark-D5C5NzOE.js}

@@ -1,4 +1,4 @@
-import { h } from './index-DH5lfRNj.js';
+import { h } from './index-DJkaRtbb.js';
 
 /**
  * Shared required-field indicator for every co-* form field, so they all render

package/dist/esm/rich-text-host-BmdKHBZP.js

@@ -0,0 +1,111 @@
+/**
+ * Cableado común de los componentes que montan un editor de cobalt-rich-text
+ * (co-rich-text-editor y co-document-editor). Extraído del RTE sin cambiar su
+ * comportamiento (spec contracts-v2-contract-editor §4.4; caracterización en
+ * co-rich-text-editor.characterization.spec.tsx). El menú flotante NO vive acá.
+ */
+/** `features` llega como objeto (propiedad JS) o como JSON (atributo HTML). */
+function parseFeatures(features) {
+    if (!features)
+        return undefined;
+    if (typeof features === 'string') {
+        try {
+            return JSON.parse(features);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    return features;
+}
+/** `value` puede ser JSON de ProseMirror o HTML; vacío = documento vacío. */
+function parseEditorValue(v) {
+    if (!v)
+        return '';
+    try {
+        return JSON.parse(v);
+    }
+    catch (_a) {
+        return v;
+    }
+}
+/**
+ * Guarda anti-eco: el padre suele devolver por `value` lo mismo que el editor
+ * acaba de emitir (en JSON o en HTML). Re-aplicarlo reinicia el editor y el
+ * cursor salta: se ignora.
+ */
+class EchoGuard {
+    constructor() {
+        this.json = null;
+        this.html = '';
+    }
+    /** Tras aplicar un valor externo (o al montar): ese valor pasa a ser el "último". */
+    seed(v) {
+        this.json = v;
+        this.html = '';
+    }
+    markEmitted(out) {
+        this.json = out.json ? JSON.stringify(out.json) : null;
+        this.html = out.html;
+    }
+    isEcho(incoming) {
+        return incoming === this.json || incoming === this.html;
+    }
+}
+/** Aplica un `value` externo sin emitir update. */
+function applyExternalValue(editor, incoming) {
+    if (incoming === '' || incoming === null) {
+        editor.commands.clearContent(false);
+    }
+    else {
+        editor.commands.setContent(parseEditorValue(incoming), { emitUpdate: false });
+    }
+}
+/** Salida `{json, html, text}` del RTE. `sanitizeHtml` lo pone el componente (preset + features). */
+function buildOutput(editor, sanitizeHtml) {
+    const empty = editor.isEmpty;
+    return {
+        json: empty ? null : editor.getJSON(),
+        html: empty ? '' : sanitizeHtml(editor.getHTML()),
+        text: editor.getText(),
+    };
+}
+/** Pasa el editor activo y el handler de imágenes a `co-rich-text-toolbar`. */
+function syncToolbarEditor(toolbarEl, editor, imageUpload) {
+    if (toolbarEl && editor && toolbarEl.editor !== editor) {
+        toolbarEl.editor = editor;
+    }
+    if (toolbarEl) {
+        toolbarEl.imageUpload = imageUpload;
+    }
+}
+/**
+ * Marca cada contenedor de imagen con su modo (`data-image-layout`) para que
+ * apliquen las reglas del CSS, y limpia el posicionamiento absoluto heredado del
+ * modelo de página fija. El NodeView de resize nunca refleja cambios de attrs en
+ * el DOM: se lee del state y se escribe el atributo a mano.
+ */
+function syncImageLayouts(editor) {
+    const view = editor.view;
+    editor.state.doc.descendants((node, pos) => {
+        var _a;
+        if (node.type.name !== 'image')
+            return true;
+        const dom = view.nodeDOM(pos);
+        const c = (((_a = dom === null || dom === void 0 ? void 0 : dom.closest) === null || _a === void 0 ? void 0 : _a.call(dom, '[data-resize-container]')) || dom);
+        if (!c)
+            return true;
+        const layout = node.attrs.imageLayout || 'inline';
+        c.dataset.imageLayout = layout;
+        c.style.position = '';
+        c.style.left = '';
+        c.style.top = '';
+        c.style.zIndex = '';
+        // El NodeView de resize fija `display: inline-flex` inline, que le gana al
+        // `display: block` del CSS en `center` / `full-width` (2026-09-17).
+        c.style.display = layout === 'center' || layout === 'full-width' ? '' : 'inline-flex';
+        return true;
+    });
+}
+
+export { EchoGuard as E, applyExternalValue as a, parseFeatures as b, buildOutput as c, syncImageLayouts as d, parseEditorValue as p, syncToolbarEditor as s };

package/dist/esm/{richTextI18n-BYKAgwq3.js → richTextI18n-xnrKkNWQ.js}

@@ -124,6 +124,21 @@ const DICT = {
         imageLayoutWrapRight: 'Wrap right',
         imageLayoutCenter: 'Center',
         imageLayoutFullWidth: 'Full width',
+        heading4: 'Heading 4',
+        headingAbbr4: 'H4',
+        field: 'Field',
+        fieldNamePlaceholder: 'Field name',
+        signature: 'Signature',
+        documentHeader: 'Header',
+        page: 'Page',
+        pageNumber: 'Page number',
+        confirmHeader: 'Confirm header',
+        zoom: 'Zoom',
+        zoomFit: 'Fit width',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Break text',
+        imageLayoutLabel: 'Image layout',
+        documentEditor: 'Document editor',
     },
     es: {
         bold: 'Negrita',
@@ -243,6 +258,21 @@ const DICT = {
         imageLayoutWrapRight: 'Ajustar a la derecha',
         imageLayoutCenter: 'Centrar',
         imageLayoutFullWidth: 'Ancho completo',
+        heading4: 'Encabezado 4',
+        headingAbbr4: 'Enc. 4',
+        field: 'Campo',
+        fieldNamePlaceholder: 'Nombre del campo',
+        signature: 'Firma',
+        documentHeader: 'Encabezado',
+        page: 'Página',
+        pageNumber: 'Número de página',
+        confirmHeader: 'Confirmar encabezado',
+        zoom: 'Zoom',
+        zoomFit: 'Ajustar al ancho',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Separar del texto',
+        imageLayoutLabel: 'Diseño de la imagen',
+        documentEditor: 'Editor de documento',
     },
     pt: {
         bold: 'Negrito',
@@ -362,6 +392,21 @@ const DICT = {
         imageLayoutWrapRight: 'Ajustar à direita',
         imageLayoutCenter: 'Centralizar',
         imageLayoutFullWidth: 'Largura total',
+        heading4: 'Título 4',
+        headingAbbr4: 'T. 4',
+        field: 'Campo',
+        fieldNamePlaceholder: 'Nome do campo',
+        signature: 'Assinatura',
+        documentHeader: 'Cabeçalho',
+        page: 'Página',
+        pageNumber: 'Número da página',
+        confirmHeader: 'Confirmar cabeçalho',
+        zoom: 'Zoom',
+        zoomFit: 'Ajustar à largura',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Separar do texto',
+        imageLayoutLabel: 'Layout da imagem',
+        documentEditor: 'Editor de documento',
     },
 };
 /** Map any BCP-47 locale (e.g. "es-CO") to a supported language; fallback 'en'. */

package/dist/esm/submenu-DU-KOQ8L.js

@@ -0,0 +1,57 @@
+/** Atributo con el que un `co-menu-item` publica hacia sus hijos el lado al que
+ *  su propio submenú terminó abriendo (post-flip). Lo escribe el componente al
+ *  recibir el `coPlacement` del popover. */
+const SUBMENU_SIDE_ATTR = 'submenu-side';
+/** Lado horizontal de un placement ya resuelto; null si es vertical (no hay
+ *  nada que heredar en una cadena que abre hacia abajo). */
+function sideOfPlacement(placement) {
+    const side = placement.split('-')[0];
+    return side === 'left' || side === 'right' ? side : null;
+}
+/** Atributo con el que `co-menu` publica hacia sus ítems si su panel terminó
+ *  abriendo hacia ARRIBA (`up`) o hacia abajo (`down`), post-flip. */
+const MENU_DIRECTION_ATTR = 'menu-direction';
+/** Dirección vertical de un placement ya resuelto del menú raíz. */
+function menuDirectionOfPlacement(placement) {
+    return placement.split('-')[0] === 'top' ? 'up' : 'down';
+}
+/** Placement que debe pedir un submenú, dado el lado al que resolvió el submenú
+ *  de su ancestro. Sin ancestro (primer nivel) mantiene el comportamiento
+ *  histórico: a la derecha, y que el flip decida.
+ *
+ *  `opensUp`: el menú raíz abrió hacia ARRIBA (trigger al pie: barra de acciones,
+ *  footer). Entonces el submenú se alinea por el BORDE INFERIOR de su fila
+ *  (`-end`) y crece hacia arriba, como el menú del que sale. Con `-start` crecía
+ *  hacia abajo y tapaba el trigger y la barra (Exportar selección → Datos,
+ *  tarea QA #12). `flip`/`shift` del popover siguen actuando si no cabe. */
+function submenuPlacement(parentSide, opensUp = false) {
+    const align = opensUp ? 'end' : 'start';
+    return parentSide === 'left' ? `left-${align}` : `right-${align}`;
+}
+/** ¿El `co-menu` que contiene a este ítem abrió hacia arriba? Los ítems (y los
+ *  anidados) son hijos de light DOM del co-menu, así que `closest` lo alcanza. */
+function menuOpensUp(el) {
+    var _a;
+    return ((_a = el.closest('co-menu')) === null || _a === void 0 ? void 0 : _a.getAttribute(MENU_DIRECTION_ATTR)) === 'up';
+}
+/**
+ * Lado heredado del `co-menu-item` ancestro más cercano, o null si no hay (o si
+ * todavía no se posicionó).
+ *
+ * Arranca en `parentElement` a propósito: `el.closest('co-menu-item')` se
+ * matchearía al PROPIO elemento — un ítem con submenú se heredaría a sí mismo y
+ * el fix sería un no-op.
+ *
+ * Funciona sobre light DOM: los `co-menu-item` anidados son hijos reales del
+ * padre en el árbol (el `<slot/>` los proyecta visualmente pero no los mueve),
+ * así que la cadena `parentElement` conserva el anidamiento a través de
+ * cualquier wrapper intermedio.
+ */
+function inheritedSubmenuSide(el) {
+    var _a;
+    const ancestor = (_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.closest('co-menu-item');
+    const side = ancestor === null || ancestor === void 0 ? void 0 : ancestor.getAttribute(SUBMENU_SIDE_ATTR);
+    return side === 'left' || side === 'right' ? side : null;
+}
+
+export { MENU_DIRECTION_ATTR as M, SUBMENU_SIDE_ATTR as S, submenuPlacement as a, menuOpensUp as b, inheritedSubmenuSide as i, menuDirectionOfPlacement as m, sideOfPlacement as s };

package/dist/esm/{toolbar-config-BAYo-RBt.js → toolbar-config-CRxTFT_z.js}

@@ -145,6 +145,20 @@ const ITEM = {
             { action: 'callout', label: 'Error', icon: 'x-circle', payload: 'error' },
         ],
     },
+    // Editor de documento (co-document-editor, preset print): paridad con V1.
+    documentHeadingStyle: {
+        action: 'headingStyle', icon: 'text-aa', label: 'Styles', type: 'dropdown',
+        options: [
+            { action: 'paragraph', label: 'Normal text' },
+            { action: 'heading', label: 'Title', payload: { level: 1 } },
+            { action: 'heading', label: 'Subtitle', payload: { level: 2 } },
+            { action: 'heading', label: 'Heading 3', payload: { level: 3 } },
+            { action: 'heading', label: 'Heading 4', payload: { level: 4 } },
+        ],
+    },
+    field: { action: 'field', icon: 'brackets-square', label: 'Field', type: 'popover' },
+    signature: { action: 'signature', icon: 'signature', label: 'Signature', type: 'button' },
+    documentHeader: { action: 'documentHeader', icon: 'layout', label: 'Header', type: 'button' },
     undo: { action: 'undo', icon: 'arrow-counter-clockwise', label: 'Undo', type: 'button' },
     redo: { action: 'redo', icon: 'arrow-clockwise', label: 'Redo', type: 'button' },
     // Table context items (shown when cursor is inside a table)
@@ -207,6 +221,24 @@ const VARIANTS = {
         SEP,
         ITEM.undo, ITEM.redo,
     ],
+    // co-document-editor (preset print): las funciones de V1 y nada más (spec §3.5, D7).
+    document: [
+        ITEM.documentHeadingStyle, ITEM.fontSize,
+        SEP,
+        ITEM.bold, ITEM.italic, ITEM.strike,
+        SEP,
+        ITEM.textColor, ITEM.highlight,
+        SEP,
+        ITEM.alignment,
+        SEP,
+        ITEM.bulletList, ITEM.orderedList,
+        SEP,
+        ITEM.link, ITEM.table, ITEM.image,
+        SEP,
+        ITEM.field, ITEM.signature, ITEM.documentHeader,
+        SEP,
+        ITEM.undo, ITEM.redo,
+    ],
 };
 /** Resolve a (non-auto) toolbar variant to its ordered list of entries. */
 function toolbarItems(variant) {

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

@@ -9,6 +9,16 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * @slot subheading - Optional secondary line under the heading (replaces `subheading` prop).
  *                    Handy for a collapsed summary/preview.
  * @slot            - Body content. Hidden when `open=false`.
+ *
+ * Wrapper Vue: `CoAccordion` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part accordion - Contenedor de la sección.
+ * @part header - Fila del encabezado (clickeable).
+ * @part heading - Título.
+ * @part subheading - Línea secundaria bajo el título.
+ * @part caret - Botón del chevron (el control accesible).
+ * @part body - Contenedor animado del cuerpo.
+ * @part body-inner - Cuerpo con su padding (slot por defecto).
  */
 export declare class CoAccordion {
     el: HTMLElement;

package/dist/types/components/co-action-bar/co-action-bar.d.ts

@@ -17,6 +17,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * disponible, o la barra desborda con varias acciones). La política de
  * contenido cuando no cabe (colapsar labels a icon-only, abreviar el conteo)
  * es del CONSUMIDOR — el componente no scrollea ni reordena.
+ * Wrapper Vue: `CoActionBar` de `@prolibu-suite/cobalt-vue`.
  *
  * @slot - Acciones de la barra (co-button surface="dark", divisores <hr>, …)
  * @slot label - Presentación custom del label. SOLO presentación: el anuncio

package/dist/types/components/co-app-shell/co-app-shell.d.ts

@@ -7,6 +7,17 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * @slot sidebar-header - Header area of the sidebar (logo, collapse button)
  * @slot sidebar-footer - Footer area of the sidebar
  * @slot - Main content area
+ *
+ * Wrapper Vue: `CoAppShell` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part sidebar - Columna lateral completa.
+ * @part sidebar-header - Cabecera de la barra lateral (slot `sidebar-header`).
+ * @part sidebar-body - Cuerpo de la barra lateral (slot `sidebar`).
+ * @part sidebar-footer - Pie de la barra lateral (slot `sidebar-footer`).
+ * @part main - Columna principal (con la sombra del panel).
+ * @part card - Tarjeta del contenido principal.
+ * @part header - Cabecera de la tarjeta (slot `navbar`).
+ * @part content - Área de contenido (slot por defecto).
  */
 export declare class CoAppShell {
     /** Sidebar display mode */

package/dist/types/components/co-audio-player/co-audio-player.d.ts

@@ -1,4 +1,16 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Reproductor de audio compacto con forma de onda: play/pausa, progreso sobre la
+ * onda, tiempo, velocidad y descarga (notas de voz, grabaciones de llamadas).
+ * Wrapper Vue: `CoAudioPlayer` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part player - Contenedor del reproductor.
+ * @part play - Botón de play/pausa.
+ * @part wave - Forma de onda (también es la barra de búsqueda).
+ * @part time - Tiempo actual / duración.
+ * @part speed - Botón de velocidad (cicla entre las velocidades; oculto en `compact`).
+ * @part download - Botón de descarga (oculto en `compact` o con `noDownload`).
+ */
 export declare class CoAudioPlayer {
     /** Audio URL (use a signedUrl for private buckets). */
     src?: string;
@@ -30,9 +42,13 @@ export declare class CoAudioPlayer {
     containerWidth: number;
     /** Current playback rate; the speed control cycles through `SPEEDS`. */
     playbackRate: number;
+    /** Empezó la reproducción. */
     coPlay: EventEmitter<void>;
+    /** Se pausó la reproducción. */
     coPause: EventEmitter<void>;
+    /** Terminó el audio (vuelve al inicio). */
     coEnded: EventEmitter<void>;
+    /** No se pudo cargar o reproducir el audio; `detail` = el evento `error` nativo del `<audio>`. */
     coError: EventEmitter<unknown>;
     /** Playback position, on the `<audio>` element's own `timeupdate` cadence
      *  (~4×/s while playing, plus every seek). Exists so a host can follow the

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

@@ -5,25 +5,42 @@ export interface AutocompleteOption {
     icon?: string;
     disabled?: boolean;
 }
+/**
+ * Campo de texto con sugerencias: al tipear emite `coSearch` (con debounce y
+ * `minChars`) y el host responde con `options`; elegir una sugerencia fija el
+ * valor. Para una lista conocida sin búsqueda remota usá `co-select` o
+ * `co-combobox`. Wrapper Vue: `CoAutocomplete` de `@prolibu-suite/cobalt-vue`.
+ */
 export declare class CoAutocomplete {
+    /** Etiqueta del campo. */
     label?: string;
     /** Whether the field is required (renders a required marker on the label). */
     required: boolean;
+    /** Texto secundario junto a la etiqueta. */
     secondaryLabel?: string;
+    /** Placeholder del input. */
     placeholder: string;
+    /** Deshabilita el campo. */
     disabled: boolean;
+    /** Ícono Phosphor al inicio del input. */
     iconLeft?: string;
+    /** Botón × para vaciar texto y selección (default `true`); emite `coClear` y `coChange`. */
     clearable: boolean;
+    /** Texto de ayuda o de error bajo el campo. */
     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';
+    /** Estado de validación: pinta el borde y el `helperText` con el color del estado. */
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     /** Pre-loaded or server-returned options */
     options: AutocompleteOption[] | string[] | string;
+    /** Selección: `value` de la opción elegida; en `multiple`, array o JSON array. El componente lo actualiza. */
     value: string | string[];
+    /** Selección múltiple: lo elegido se muestra como chips. */
     multiple: boolean;
+    /** El host está buscando: muestra un loader en la lista de sugerencias. */
     loading: boolean;
     /** Minimum characters before emitting coSearch */
     minChars: number;
@@ -38,6 +55,9 @@ export declare class CoAutocomplete {
     private optionListEl?;
     /** Fired when the user types (after debounce). Host should fetch and set options. */
     coSearch: EventEmitter<string>;
+    /** Cambió la selección (`value` ya está actualizado): `{ value, item }`. `value` = el elegido o
+     *  el array en `multiple`; `null` (con `item: null`) al deseleccionar desde la lista;
+     *  `''`/`[]` (con `item: null`) al vaciar con la ×. */
     coChange: EventEmitter<{
         value: string | string[] | null;
         item: {
@@ -45,6 +65,7 @@ export declare class CoAutocomplete {
             label: string;
         } | null;
     }>;
+    /** Se vació con la ×; le sigue un `coChange`. Sin `detail`. */
     coClear: EventEmitter<void>;
     private debounceTimer?;
     private inputEl?;

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

@@ -1,3 +1,10 @@
+/**
+ * Avatar de una persona o entidad: iniciales, ícono o imagen, en círculo,
+ * squircle o cuadrado de radio chico. Con `name` muestra el nombre completo en
+ * un `co-tooltip`. Wrapper Vue: `CoAvatar` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part avatar - Caja del avatar (fondo, máscara y anillo).
+ */
 export declare class CoAvatar {
     /** Display type: text shows initials, icon shows a Phosphor icon, image shows a picture */
     type: 'text' | 'icon' | 'image';
@@ -13,8 +20,10 @@ export declare class CoAvatar {
     icon: string;
     /** Icon weight */
     iconWeight: 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
-    /** Shape of the avatar */
-    shape: 'circle' | 'square';
+    /** Shape of the avatar. `rounded` = radio chico
+     *  (`--co-border-radius-xs`), sin máscara squircle — esquinas de radio fijo,
+     *  no la superelipse de `square`. */
+    shape: 'circle' | 'square' | 'rounded';
     /** Custom background color (hex or CSS value) */
     color?: string;
     /** Optional 2px ring color (hex/CSS). Drives the inset ::after ring. */

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

@@ -12,6 +12,11 @@ export interface CoAvatarGroupItem {
     /** Optional ring color forwarded to the child `co-avatar`. */
     ringColor?: string;
 }
+/**
+ * Pila de avatares superpuestos con un «+N» para los que no entran (`max`).
+ * `items` describe cada avatar (tipo, texto, imagen, color). Wrapper Vue:
+ * `CoAvatarGroup` de `@prolibu-suite/cobalt-vue`.
+ */
 export declare class CoAvatarGroup {
     /** Avatar descriptors rendered as an overlapping stack. */
     items: CoAvatarGroupItem[];

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

@@ -1,3 +1,10 @@
+/**
+ * Indicador pequeño de conteo o de estado (punto) con color semántico; con
+ * `animated` hace un pop de entrada. Wrapper Vue: `CoBadge` de
+ * `@prolibu-suite/cobalt-vue`.
+ *
+ * @part badge - El indicador.
+ */
 export declare class CoBadge {
     /**
      * Size: large=16px dot, small=6px dot

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

@@ -11,6 +11,15 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * @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.
+ *
+ * Wrapper Vue: `CoBottomSheet` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @part backdrop - Fondo oscuro detrás de la hoja.
+ * @part sheet - La hoja.
+ * @part handle - Tirador superior.
+ * @part header - Encabezado (título o slot `header`).
+ * @part body - Cuerpo scrolleable.
+ * @part footer - Área de acciones fija al pie.
  */
 export declare class CoBottomSheet {
     el: HTMLElement;

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

@@ -6,6 +6,10 @@
  * 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.
+ *
+ * @part breadcrumb - El propio elemento (`role="navigation"`), fila de migas.
+ *
+ * Wrapper Vue: `CoBreadcrumb` de `@prolibu-suite/cobalt-vue`.
  */
 export declare class CoBreadcrumb {
     el: HTMLElement;

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

@@ -9,6 +9,12 @@ import { EventEmitter } from '../../stencil-public-runtime';
  *
  * Conventions mirror `co-menu-item`: the `current` crumb paints medium weight +
  * text-default ink; earlier crumbs are regular weight + muted (gray-500).
+ *
+ * Wrapper Vue: `CoBreadcrumbItem` de `@prolibu-suite/cobalt-vue`.
+ *
+ * @slot - Contenido propio en lugar de `label`.
+ * @part breadcrumb-item - Contenedor de la miga (separador + contenido).
+ * @part content - Parte clickeable (ícono y texto).
  */
 export declare class CoBreadcrumbItem {
     /** Text shown in the crumb. */