@prolibu-suite/cobalt-core 0.10.4 → 0.11.0

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-avatar/co-avatar.d.ts

@@ -13,8 +13,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` (Task C12) = 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-button/co-button.d.ts

@@ -2,12 +2,14 @@
  * @slot - Button label text
  */
 export declare class CoButton {
-    /** Visual style */
-    variant: 'primary' | 'secondary' | 'stroke' | 'ghost' | 'danger' | 'success';
+    /** Visual style. "soft" (Task C2, Fase 2 Cobalt): fondo gray-100 sólido, sin backdrop-filter — pensado para toolbars/paneles del editor. */
+    variant: 'primary' | 'secondary' | 'stroke' | 'ghost' | 'danger' | 'success' | 'soft';
     /** Shape: pill or straight corners */
     shape: 'rounded' | 'square';
-    /** Size */
-    size: 'l' | 'm' | 's' | 'xs';
+    /** Size. "sm" (Task C2, Fase 2 Cobalt): 32px fijo — escala unificada de tallas nuevas del editor (xs=24/s=28/sm=32). */
+    size: 'l' | 'm' | 's' | 'xs' | 'sm';
+    /** Ocupa el 100% del ancho del contenedor (Task C2, Fase 2 Cobalt). Reflejado como atributo `full-width`. */
+    fullWidth: boolean;
     /** Raised elevation — with variant="secondary" renders a white raised button (shadow-sm + inset hairline). */
     elevated: boolean;
     /**

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

@@ -0,0 +1,15 @@
+/**
+ * Fechas MARCADAS de co-calendar (feriados, hitos): se ven distintas pero siguen siendo
+ * seleccionables, a diferencia de `disabledDates`. Lógica pura para testear sin montar.
+ */
+/** Array, JSON (`'["2026-12-25"]'`) o CSV (`'2026-12-25, 2027-01-01'`) → string[]. */
+export declare function normalizeStringArray(v: string[] | string | undefined): string[];
+/** Set de `YYYY-MM-DD` válidos para consultar por día en O(1). */
+export declare function normalizeMarkedDates(v: string[] | string | undefined): Set<string>;
+/** El texto de marca lo da el anfitrión (i18n suya): «25 de diciembre de 2026, Feriado». */
+export declare function dayAriaLabel(base: string, marked: boolean, markedLabel?: string): string;
+/** `YYYY-MM` → { year, month } (mes 1–12) para anclar la vista; null si no es válido. */
+export declare function parseViewMonth(v: string | undefined | null): {
+    year: number;
+    month: number;
+} | null;

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

@@ -30,6 +30,19 @@ export declare class CoCalendar {
     max?: string;
     /** Blocked dates. Accepts a string[] or a JSON/comma string for raw-HTML use. */
     disabledDates?: string[] | string;
+    /**
+     * Fechas `YYYY-MM-DD` que se MARCAN (feriados, hitos) sin deshabilitarlas: se pueden
+     * seleccionar igual. Array, JSON o CSV, como `disabledDates`. Color por la custom
+     * property `--co-calendar-marked-bg` (default: token de Cobalt).
+     */
+    markedDates?: string[] | string;
+    /** Texto accesible que se suma al día marcado («Feriado»). Lo traduce el anfitrión. */
+    markedLabel?: string;
+    /**
+     * Mes que muestra la vista (`YYYY-MM`), por encima del ancla de la selección. Para
+     * poner dos calendarios lado a lado (inicio y fin de un rango en meses distintos).
+     */
+    month?: string;
     /** Blocked weekdays (0=Sun..6=Sat). Accepts number[] or a JSON/comma string. */
     disabledDaysOfWeek?: number[] | string;
     /** BCP-47 locale used for month/weekday labels. */
@@ -60,6 +73,8 @@ export declare class CoCalendar {
     /** When set, focus the matching day cell after the next render. */
     private shouldFocusGrid;
     componentWillLoad(): void;
+    onMonthChange(): void;
+    private applyMonthProp;
     onValueChange(): void;
     /** Move keyboard focus into the grid (used by the picker when the popover opens). */
     focusGrid(): Promise<void>;
@@ -99,6 +114,7 @@ export declare class CoCalendar {
     private focusFocusedCell;
     /** Range endpoint/in-range flags for a cell, accounting for hover preview. */
     private rangeFlags;
+    private get markedSet();
     private dayClass;
     private headerTitle;
     private renderDays;

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

@@ -6,6 +6,13 @@ export declare class CoCheckbox {
     indeterminate: boolean;
     /** Size: small=16px, medium=20px, large=24px (overlay appearance: small=20px, medium/large=22px) */
     size: 'small' | 'medium' | 'large';
+    /**
+     * Talla del label: 'default' (14px, sin cambios) o 'xs' (12px/400/text-default,
+     * gap 6). Con 'xs' la caja SIN MARCAR pasa a fondo transparente + borde
+     * `--co-semantic-border-default` pleno (hoy surface-secondary 35% + borde 75%);
+     * el estado marcado no cambia. Aditivo — el default sigue siendo idéntico.
+     */
+    labelSize: 'default' | 'xs';
     /** Disabled state */
     disabled: boolean;
     /** Label text displayed beside the checkbox */

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

@@ -0,0 +1,64 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/** Payload de `coInput` / `coChange`: saturación y valor en 0–100. */
+export interface ColorAreaDetail {
+    saturation: number;
+    value: number;
+}
+/**
+ * Área saturación/valor (el "cuadrado" del picker de color). El tono viene de
+ * afuera (`hue`, normalmente de un `co-color-slider channel="hue"`); el usuario
+ * elige saturación (eje X) y valor (eje Y) arrastrando o con el teclado.
+ *
+ * Contrato de eventos (pensado para el historial de deshacer del editor):
+ *  - `coInput`  → en cada movimiento del arrastre (vista previa) y en cada paso
+ *                 de teclado.
+ *  - `coChange` → UNA vez al terminar el gesto (pointerup/pointercancel), solo
+ *                 si el gesto cambió el valor, o tras cada paso de teclado que
+ *                 lo cambie. Es el punto de commit: nunca un commit vacío.
+ *
+ * Los valores de puntero NO se redondean (una caja de 236 px da ~0,4 % por
+ * píxel; redondear a enteros dejaría hex inalcanzables). El teclado suma ±1
+ * (±10 con Shift) sobre el valor vigente. Quien muestre números redondea.
+ *
+ * @part thumb - El indicador circular (16 px, anillo blanco + color actual).
+ */
+export declare class CoColorArea {
+    el: HTMLElement;
+    /** Tono 0–360. Pinta el fondo; el área no lo modifica. */
+    hue: number;
+    /** Saturación 0–100 (eje X). Mutable: el área se actualiza sola al arrastrar. */
+    saturation: number;
+    /** Valor/brillo 0–100 (eje Y, 100 arriba). Mutable: el área se actualiza sola al arrastrar. */
+    value: number;
+    /** Deshabilita puntero y teclado; no emite nada. */
+    disabled: boolean;
+    /** Nombre accesible del slider (`aria-label`). */
+    label?: string;
+    /** Vista previa: cada movimiento del arrastre y cada paso de teclado. */
+    coInput: EventEmitter<ColorAreaDetail>;
+    /** Commit: una vez al soltar (o cancelar) el gesto si cambió el valor, y tras cada paso de teclado que lo cambie. */
+    coChange: EventEmitter<ColorAreaDetail>;
+    private dragging;
+    private areaEl?;
+    /** pointerId del gesto en curso: los eventos de OTRO puntero (segundo dedo) se ignoran. */
+    private activePointerId?;
+    /** ¿Algún coInput real durante el gesto? Sin cambio no hay coChange de cierre. */
+    private changedInGesture;
+    private get detail();
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerEnd;
+    /** `==`: en jsdom los MouseEvent traen `pointerId` undefined y deben seguir pasando. */
+    private isActivePointer;
+    /** `setPointerCapture` sigue el gesto fuera de la caja. jsdom no lo implementa
+     *  y un browser lanza NotFoundError con un pointerId sintético: guardado. */
+    private capturePointer;
+    private releasePointer;
+    /** clientX/Y → saturación (X, 0 izquierda) y valor (Y, 100 arriba), acotados a la caja. */
+    private applyPointer;
+    /** Aplica s/v y emite `coInput` solo si algo cambió (los moves repetidos no
+     *  disparan re-render ni trabajo en el host). */
+    private commitInput;
+    private handleKeyDown;
+    render(): any;
+}

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

@@ -0,0 +1,61 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+export type ColorSliderChannel = 'hue' | 'alpha';
+/**
+ * Slider de un canal del picker de color: tono (`hue`, 0–360) u opacidad
+ * (`alpha`, 0–100, sobre el color base `color`).
+ *
+ * Contrato de eventos (mismo que `co-color-area`, pensado para el historial del
+ * editor): `coInput` en cada movimiento del arrastre y en cada paso de teclado;
+ * `coChange` UNA vez al terminar el gesto (pointerup/pointercancel), solo si el
+ * gesto cambió el valor, o tras cada paso de teclado que lo cambie — nunca un
+ * commit vacío. Ambos llevan el valor numérico.
+ *
+ * El thumb (16 px) va INSET: su centro recorre [8 px, ancho − 8 px], así nunca
+ * se sale del track de 16 px de alto. El puntero usa el mismo mapeo, de modo
+ * que el color bajo el thumb es exactamente el valor emitido.
+ *
+ * @part track - La pista (gradiente de tono o damero + transparente→color).
+ * @part thumb - El indicador circular (16 px, anillo blanco + color actual).
+ */
+export declare class CoColorSlider {
+    el: HTMLElement;
+    /** Canal: `hue` (0–360, gradiente HSL uniforme) o `alpha` (0–100, damero). */
+    channel: ColorSliderChannel;
+    /** Valor actual (tono 0–360 / alpha 0–100). Mutable: el slider se actualiza solo al arrastrar. */
+    value: number;
+    /** Color base para `channel="alpha"` (cualquier color CSS; el track va de transparente a él). */
+    color?: string;
+    /** Deshabilita puntero y teclado; no emite nada. */
+    disabled: boolean;
+    /** Nombre accesible del slider (`aria-label`). */
+    label?: string;
+    /** Vista previa: cada movimiento del arrastre y cada paso de teclado. */
+    coInput: EventEmitter<number>;
+    /** Commit: una vez al soltar (o cancelar) el gesto si cambió el valor, y tras cada paso de teclado que lo cambie. */
+    coChange: EventEmitter<number>;
+    private dragging;
+    private trackEl?;
+    private thumbEl?;
+    /** pointerId del gesto en curso: los eventos de OTRO puntero (segundo dedo) se ignoran. */
+    private activePointerId?;
+    /** ¿Algún coInput real durante el gesto? Sin cambio no hay coChange de cierre. */
+    private changedInGesture;
+    private get max();
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerEnd;
+    /** `==`: en jsdom los MouseEvent traen `pointerId` undefined y deben seguir pasando. */
+    private isActivePointer;
+    /** `setPointerCapture` sigue el gesto fuera del track. jsdom no lo implementa
+     *  y un browser lanza NotFoundError con un pointerId sintético: guardado. */
+    private capturePointer;
+    private releasePointer;
+    /** clientX → valor, con el recorrido del thumb inset (centro en [size/2, ancho − size/2]). */
+    private applyPointer;
+    /** Aplica el valor y emite `coInput` solo si cambió. */
+    private commitInput;
+    private handleKeyDown;
+    /** Relleno del thumb: el tono puro, o el color base con la opacidad actual sobre damero. */
+    private thumbFill;
+    render(): any;
+}

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

@@ -14,7 +14,7 @@ import type { Placement } from '../../utils/positioning';
  * (`@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
+ * `timeZone` at `DEFAULT_MINUTES` (09:00), never as UTC midnight (which
  * would shift the day west of UTC).
  *
  * INTERACTION (Google):

package/dist/types/components/co-document-editor/change-throttle.d.ts

@@ -0,0 +1,9 @@
+/** Ventana de `coChange`: avisa como mucho cada 250 ms (nunca por tecla). */
+export declare const DOC_CHANGE_THROTTLE_MS = 250;
+export interface Throttle {
+    run(): void;
+    flush(): void;
+    cancel(): void;
+    readonly pending: boolean;
+}
+export declare function createThrottle(ms: number, fn: () => void): Throttle;